src/ui/controls/FUiCtrl_GroupContainerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /*
  19  * @file                FUiCtrl_GroupContainerImpl.cpp
  20  * @brief               This is the implementation file for the _GroupContainerImpl class.
  21  *
  22  */
  23
  24 #include <FBaseErrors.h>
  25 #include <FBaseSysLog.h>
  26 #include <FBase_LocalizedNumParser.h>
  27 #include "FUiCtrl_GroupContainerImpl.h"
  28 #include "FUi_CoordinateSystemUtils.h"
  29 #include "FUi_UiBuilder.h"
  30
  31 using namespace Tizen::Graphics;
  32 using namespace Tizen::Base;
  33
  34 namespace Tizen { namespace Ui { namespace Controls
  35 {
  36 _GroupContainerImpl::_GroupContainerImpl(Control* pPublic, _Control* pCore)
  37 : _ContainerImpl(pPublic, pCore)
  38 {
  39
  40 }
  41
  42 _GroupContainerImpl::~_GroupContainerImpl(void)
  43 {
  44         // nothing
  45 }
  46
  47 _GroupContainerImpl*
  48 _GroupContainerImpl::CreateGroupContainerImplN(GroupContainer* pControl, const Rectangle& rect, int rowCount, int columnCount, int lineWidth)
  49 {
  50         ClearLastResult();
  51
  52         _GroupContainerImpl* pImpl = null;
  53         _GroupContainer* pCore = null;
  54
  55         FloatRectangle floatBounds = _CoordinateSystemUtils::ConvertToFloat(rect);
  56         float floatLineWidth = _CoordinateSystemUtils::ConvertToFloat(lineWidth);
  57
  58         pCore = _GroupContainer::CreateGroupContainerN(floatBounds, rowCount, columnCount, floatLineWidth);
  59         result r = GetLastResult();
  60         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  61
  62         pImpl = new (std::nothrow) _GroupContainerImpl(pControl, pCore);
  63         r = CheckConstruction(pCore, pImpl);
  64         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  65
  66         return pImpl;
  67 }
  68
  69 _GroupContainerImpl*
  70 _GroupContainerImpl::CreateGroupContainerImplFN(GroupContainer* pControl, const FloatRectangle& rect, int rowCount, int columnCount, float lineWidth)
  71 {
  72         ClearLastResult();
  73
  74         _GroupContainerImpl* pImpl = null;
  75         _GroupContainer* pCore = null;
  76
  77         pCore = _GroupContainer::CreateGroupContainerN(rect, rowCount, columnCount, lineWidth);
  78         result r = GetLastResult();
  79         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  80
  81         pImpl = new (std::nothrow) _GroupContainerImpl(pControl, pCore);
  82         r = CheckConstruction(pCore, pImpl);
  83         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  84
  85         return pImpl;
  86 }
  87
  88 void
  89 _GroupContainerImpl::Initialize(void)
  90 {
  91         GetCore().SetImpl(this);
  92 }
  93
  94 const _GroupContainerImpl*
  95 _GroupContainerImpl::GetInstance(const GroupContainer& grpContainer)
  96 {
  97         return static_cast<const _GroupContainerImpl*>(_ControlImpl::GetInstance(grpContainer));
  98 }
  99
 100 _GroupContainerImpl*
 101 _GroupContainerImpl::GetInstance(GroupContainer& grpContainer)
 102 {
 103         return static_cast<_GroupContainerImpl*>(_ControlImpl::GetInstance(grpContainer));
 104 }
 105
 106 const char*
 107 _GroupContainerImpl::GetPublicClassName(void) const
 108 {
 109         return "Tizen::Ui::Controls::GroupContainer";
 110 }
 111
 112 const GroupContainer&
 113 _GroupContainerImpl::GetPublic(void) const
 114 {
 115         return static_cast <const GroupContainer&>(_ControlImpl::GetPublic());
 116 }
 117
 118 GroupContainer&
 119 _GroupContainerImpl::GetPublic(void)
 120 {
 121         return static_cast <GroupContainer&>(_ControlImpl::GetPublic());
 122 }
 123
 124 const _GroupContainer&
 125 _GroupContainerImpl::GetCore(void) const
 126 {
 127         return static_cast <const _GroupContainer&>(_ControlImpl::GetCore());
 128 }
 129
 130 _GroupContainer&
 131 _GroupContainerImpl::GetCore(void)
 132 {
 133         return static_cast <_GroupContainer&>(_ControlImpl::GetCore());
 134 }
 135
 136 result
 137 _GroupContainerImpl::AddControlAt(Control &control, int rowIndex, int rolumnIndex)
 138 {
 139         result r = GetCore().AddControlAt(control, rowIndex, rolumnIndex);
 140         SetLastResultReturn(r);
 141 }
 142
 143 Control*
 144 _GroupContainerImpl::GetControlAt(int rowIndex, int columnIndex)
 145 {
 146         ClearLastResult();
 147
 148         return GetCore().GetControlAt(rowIndex, columnIndex);
 149 }
 150
 151 result
 152 _GroupContainerImpl::RemoveControlAt(int rowIndex, int columnIndex)
 153 {
 154         result r = GetCore().RemoveControlAt(rowIndex, columnIndex);
 155         SetLastResultReturn(r);
 156 }
 157
 158 result
 159 _GroupContainerImpl::SetColumnWidth(int columnIndex, int width)
 160 {
 161         float floatWidth = _CoordinateSystemUtils::ConvertToFloat(width);
 162         result r = GetCore().SetColumnWidth(columnIndex, floatWidth);
 163         SetLastResultReturn(r);
 164 }
 165
 166 result
 167 _GroupContainerImpl::SetColumnWidth(int columnIndex, float width)
 168 {
 169         result r = GetCore().SetColumnWidth(columnIndex, width);
 170         SetLastResultReturn(r);
 171 }
 172
 173 int
 174 _GroupContainerImpl::GetColumnWidth(int columnIndex)
 175 {
 176         ClearLastResult();
 177
 178         int width = _CoordinateSystemUtils::ConvertToInteger(GetCore().GetColumnWidth(columnIndex));
 179         return width;
 180 }
 181
 182 float
 183 _GroupContainerImpl::GetColumnWidthF(int columnIndex)
 184 {
 185         ClearLastResult();
 186
 187         return GetCore().GetColumnWidth(columnIndex);
 188 }
 189
 190 result
 191 _GroupContainerImpl::SetRowHeight(int rowIndex, int height)
 192 {
 193         float floatHeight = _CoordinateSystemUtils::ConvertToFloat(height);
 194         result r = GetCore().SetRowHeight(rowIndex, floatHeight);
 195         SetLastResultReturn(r);
 196 }
 197
 198 result
 199 _GroupContainerImpl::SetRowHeight(int rowIndex, float height)
 200 {
 201         result r = GetCore().SetRowHeight(rowIndex, height);
 202         SetLastResultReturn(r);
 203 }
 204
 205 int
 206 _GroupContainerImpl::GetRowHeight(int rowIndex)
 207 {
 208         ClearLastResult();
 209
 210         return _CoordinateSystemUtils::ConvertToInteger(GetCore().GetRowHeight(rowIndex));
 211 }
 212
 213 float
 214 _GroupContainerImpl::GetRowHeightF(int rowIndex)
 215 {
 216         ClearLastResult();
 217
 218         return GetCore().GetRowHeight(rowIndex);
 219 }
 220
 221 result
 222 _GroupContainerImpl::Merge(int rowStartIndex, int columnStartIndex, int rowCount, int columnCount)
 223 {
 224         result r = GetCore().Merge(rowStartIndex, columnStartIndex, rowCount, columnCount);
 225
 226         SetLastResultReturn(r);
 227 }
 228
 229 result
 230 _GroupContainerImpl::SetChildResizingEnabled(int rowIndex, int columnIndex, bool enable)
 231 {
 232         result r = GetCore().SetChildResizingEnabled(rowIndex, columnIndex, enable);
 233         SetLastResultReturn(r);
 234 }
 235
 236 result
 237 _GroupContainerImpl::SetMargin(int rowIndex, int columnIndex, int leftMargin, int rightMargin, int topMargin, int bottomMargin)
 238 {
 239         float floatLeftMargin = _CoordinateSystemUtils::ConvertToFloat(leftMargin);
 240         float floatRightMargin = _CoordinateSystemUtils::ConvertToFloat(rightMargin);
 241         float floatTopMargin = _CoordinateSystemUtils::ConvertToFloat(topMargin);
 242         float floatBottomMargin = _CoordinateSystemUtils::ConvertToFloat(bottomMargin);
 243
 244         result r = GetCore().SetMargin(rowIndex, columnIndex, floatLeftMargin, floatRightMargin, floatTopMargin, floatBottomMargin);
 245         SetLastResultReturn(r);
 246 }
 247
 248 result
 249 _GroupContainerImpl::SetMargin(int rowIndex, int columnIndex, float leftMargin, float rightMargin, float topMargin, float bottomMargin)
 250 {
 251         result r = GetCore().SetMargin(rowIndex, columnIndex, leftMargin, rightMargin, topMargin, bottomMargin);
 252         SetLastResultReturn(r);
 253 }
 254
 255 result
 256 _GroupContainerImpl::Split(int rowIndex, int columnIndex)
 257 {
 258         result r = GetCore().Split(rowIndex, columnIndex);
 259         SetLastResultReturn(r);
 260 }
 261
 262 Rectangle
 263 _GroupContainerImpl::GetBoundsAt(int rowIndex, int columnIndex) const
 264 {
 265         ClearLastResult();
 266
 267         return _CoordinateSystemUtils::ConvertToInteger(GetCore().GetBoundsAt(rowIndex, columnIndex));
 268 }
 269
 270 FloatRectangle
 271 _GroupContainerImpl::GetBoundsAtF(int rowIndex, int columnIndex) const
 272 {
 273         ClearLastResult();
 274
 275         return GetCore().GetBoundsAt(rowIndex, columnIndex);
 276 }
 277
 278 result
 279 _GroupContainerImpl::SetColumnStretchable(int columnIndex, bool stretchable)
 280 {
 281         result r = GetCore().SetColumnStretchable(columnIndex, stretchable);
 282         SetLastResultReturn(r);
 283 }
 284
 285 bool
 286 _GroupContainerImpl::IsColumnStretchable(int columnIndex)
 287 {
 288         ClearLastResult();
 289
 290         return GetCore().IsColumnStretchable(columnIndex);
 291 }
 292
 293 result
 294 _GroupContainerImpl::SetRowStretchable(int rowIndex, bool stretchable)
 295 {
 296         result r = GetCore().SetRowStretchable(rowIndex, stretchable);
 297         SetLastResultReturn(r);
 298 }
 299
 300 bool
 301 _GroupContainerImpl::IsRowStretchable(int rowIndex)
 302 {
 303         ClearLastResult();
 304
 305         return GetCore().IsRowStretchable(rowIndex);
 306 }
 307
 308 void
 309 _GroupContainerImpl::SetLineColor(const Color& color)
 310 {
 311         ClearLastResult();
 312
 313         GetCore().SetLineColor(color);
 314
 315         return;
 316 }
 317
 318 Color
 319 _GroupContainerImpl::GetLineColor(void)
 320 {
 321         ClearLastResult();
 322
 323         return GetCore().GetLineColor();
 324 }
 325
 326 class _GroupContainerMaker
 327         : public _UiBuilderControlMaker
 328 {
 329 public:
 330         _GroupContainerMaker(_UiBuilder* pUiBuilder)
 331                 : _UiBuilderControlMaker(pUiBuilder){};
 332         virtual ~_GroupContainerMaker(void){};
 333
 334         static _UiBuilderControlMaker*
 335         GetInstance(_UiBuilder* pUiBuilder)
 336         {
 337                 _GroupContainerMaker* pGroupContainerMaker = new (std::nothrow) _GroupContainerMaker(pUiBuilder);
 338                 SysTryReturn(NID_UI_CTRL, pGroupContainerMaker, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 339
 340                 return pGroupContainerMaker;
 341         };
 342
 343 protected:
 344         virtual Control*
 345         Make(_UiBuilderControl* pControl)
 346         {
 347                 result r = E_SYSTEM;
 348                 _UiBuilderControlLayout* pControlProperty = null;
 349                 GroupContainer* pGroupContainer = null;
 350                 FloatRectangle rect(0.0f, 0.0f, 0.0f, 0.0f);
 351                 String elementString = L"";
 352                 int rowCount = 1;
 353                 int columnCount = 1;
 354                 float lineWidth = 1.0f;
 355                 Color backgroundColor(0, 0, 0, 0);
 356                 Color lineColor(0, 0, 0, 0);
 357
 358                 GetProperty(pControl, &pControlProperty);
 359
 360                 if (pControlProperty == null)
 361                 {
 362                         return null;
 363                 }
 364
 365                 if (pControl->GetElement("rowCount", elementString))
 366                 {
 367                         Integer::Parse(elementString, rowCount);
 368                 }
 369
 370                 if (pControl->GetElement("columnCount", elementString))
 371                 {
 372                         Integer::Parse(elementString, columnCount);
 373                 }
 374
 375                 if (pControl->GetElement("lineWidth", elementString))
 376                 {
 377                         lineWidth = _LocalizedNumParser::ToDouble(elementString, "C");
 378                 }
 379
 380                 rect = pControlProperty->GetRectF();
 381
 382                 pGroupContainer = new (std::nothrow) GroupContainer();
 383                 SysTryReturn(NID_UI_CTRL, pGroupContainer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 384
 385                 // Construct
 386                 r = pGroupContainer->Construct(rect, rowCount, columnCount, lineWidth);
 387
 388                 if (r != E_SUCCESS)
 389                 {
 390                         SysLog(NID_UI_CTRL, "Failed to create GroupContainer.");
 391
 392                         delete pGroupContainer;
 393                         pGroupContainer = null;
 394
 395                         return null;
 396                 }
 397
 398                 if (pControl->GetElement(L"backgroundColor", elementString))
 399                 {
 400                         ConvertStringToColor(elementString, backgroundColor);
 401                         pGroupContainer->SetBackgroundColor(backgroundColor);
 402                 }
 403
 404                 if (pControl->GetElement(L"lineColor", elementString))
 405                 {
 406                         ConvertStringToColor(elementString, lineColor);
 407                         pGroupContainer->SetBackgroundColor(lineColor);
 408                 }
 409
 410                 return pGroupContainer;
 411         }
 412 }; // _GroupContainerMaker
 413
 414 _GroupContainerRegister::_GroupContainerRegister(void)
 415 {
 416         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 417         if (pUiBuilderControlTableManager)
 418         {
 419                 pUiBuilderControlTableManager->RegisterControl(L"GroupContainer", _GroupContainerMaker::GetInstance);
 420         }
 421 }
 422
 423 _GroupContainerRegister::~_GroupContainerRegister(void)
 424 {
 425         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 426         if (pUiBuilderControlTableManager)
 427         {
 428                 pUiBuilderControlTableManager->UnregisterControl(L"GroupContainer");
 429         }
 430 }
 431 static _GroupContainerRegister GroupContainerRegisterToUiBuilder;
 432 }}} //Tizen::Ui::Controls
 433