src/ui/FUi_LayoutImpl.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  * @file                FUi_LayoutImpl.cpp
  19  * @brief       This is the implementation file for _Layout class.
  20  *
  21  * This file contains the implementation of _Layout class.
  22  */
  23
  24 #include <FUiLayout.h>
  25 #include <FUiRelativeLayout.h>
  26 #include <FUiGridLayout.h>
  27 #include <FUiVerticalBoxLayout.h>
  28 #include <FUiHorizontalBoxLayout.h>
  29 #include <FUiCardLayout.h>
  30 #include "FUi_LayoutImpl.h"
  31
  32 using namespace Tizen::Base;
  33
  34 namespace Tizen { namespace Ui
  35 {
  36
  37 namespace
  38 {
  39 static const int CONVERT_ERROR_CODE = -1;
  40
  41 _Layout::HorizontalAlign
  42 ConvertEnum(const LayoutHorizontalAlignment val)
  43 {
  44         switch (val)
  45         {
  46         case LAYOUT_HORIZONTAL_ALIGN_LEFT:
  47                 return _Layout::ITEM_HORIZONTAL_ALIGN_LEFT;
  48
  49         case LAYOUT_HORIZONTAL_ALIGN_RIGHT:
  50                 return _Layout::ITEM_HORIZONTAL_ALIGN_RIGHT;
  51
  52         case LAYOUT_HORIZONTAL_ALIGN_CENTER:
  53                 return _Layout::ITEM_HORIZONTAL_ALIGN_CENTER;
  54
  55         default:
  56                 return static_cast <_Layout::HorizontalAlign>(CONVERT_ERROR_CODE);
  57         }
  58 }
  59
  60 LayoutHorizontalAlignment
  61 ConvertEnum(const _Layout::HorizontalAlign val)
  62 {
  63         switch (val)
  64         {
  65         case _Layout::ITEM_HORIZONTAL_ALIGN_LEFT:
  66                 return LAYOUT_HORIZONTAL_ALIGN_LEFT;
  67
  68         case _Layout::ITEM_HORIZONTAL_ALIGN_RIGHT:
  69                 return LAYOUT_HORIZONTAL_ALIGN_RIGHT;
  70
  71         case _Layout::ITEM_HORIZONTAL_ALIGN_CENTER:
  72                 return LAYOUT_HORIZONTAL_ALIGN_CENTER;
  73
  74         default:
  75                 return static_cast <LayoutHorizontalAlignment>(CONVERT_ERROR_CODE);
  76         }
  77 }
  78
  79 _Layout::VerticalAlign
  80 ConvertEnum(const LayoutVerticalAlignment val)
  81 {
  82         switch (val)
  83         {
  84         case LAYOUT_VERTICAL_ALIGN_TOP:
  85                 return _Layout::ITEM_VERTICAL_ALIGN_TOP;
  86
  87         case LAYOUT_VERTICAL_ALIGN_BOTTOM:
  88                 return _Layout::ITEM_VERTICAL_ALIGN_BOTTOM;
  89
  90         case LAYOUT_VERTICAL_ALIGN_MIDDLE:
  91                 return _Layout::ITEM_VERTICAL_ALIGN_MIDDLE;
  92
  93         default:
  94                 return static_cast <_Layout::VerticalAlign>(CONVERT_ERROR_CODE);
  95         }
  96 }
  97
  98 LayoutVerticalAlignment
  99 ConvertEnum(const _Layout::VerticalAlign val)
 100 {
 101         switch (val)
 102         {
 103         case _Layout::ITEM_VERTICAL_ALIGN_TOP:
 104                 return LAYOUT_VERTICAL_ALIGN_TOP;
 105
 106         case _Layout::ITEM_VERTICAL_ALIGN_BOTTOM:
 107                 return LAYOUT_VERTICAL_ALIGN_BOTTOM;
 108
 109         case _Layout::ITEM_VERTICAL_ALIGN_MIDDLE:
 110                 return LAYOUT_VERTICAL_ALIGN_MIDDLE;
 111
 112         default:
 113                 return static_cast <LayoutVerticalAlignment>(CONVERT_ERROR_CODE);
 114         }
 115 }
 116
 117 _Layout::LayoutMatchMode
 118 ConvertEnum(FitPolicy val)
 119 {
 120         switch (val)
 121         {
 122         case FIT_POLICY_FIXED:
 123                 return _Layout::NONE_MODE;
 124
 125         case FIT_POLICY_CONTENT:
 126                 return _Layout::WRAP_CONTENT;
 127
 128         case FIT_POLICY_PARENT:
 129                 return _Layout::MATCH_PARENT;
 130
 131         default:
 132                 return static_cast <_Layout::LayoutMatchMode>(CONVERT_ERROR_CODE);
 133         }
 134 }
 135
 136 FitPolicy
 137 ConvertEnum(_Layout::LayoutMatchMode val)
 138 {
 139         switch (val)
 140         {
 141         case _Layout::NONE_MODE:
 142                 return FIT_POLICY_FIXED;
 143
 144         case _Layout::WRAP_CONTENT:
 145                 return FIT_POLICY_CONTENT;
 146
 147         case _Layout::MATCH_PARENT:
 148                 return FIT_POLICY_PARENT;
 149
 150         default:
 151                 return static_cast <FitPolicy>(CONVERT_ERROR_CODE);
 152         }
 153 }
 154 }
 155
 156 // _LayoutImpl implementation
 157 _LayoutImpl::_LayoutImpl(Layout* pPublicLayout, _Layout::Layout* pCoreLayout)
 158         : _pPublicLayout(pPublicLayout)
 159         , _pCoreLayout(pCoreLayout)
 160 {
 161 }
 162
 163 _LayoutImpl::~_LayoutImpl()
 164 {
 165         delete _pCoreLayout;
 166 }
 167
 168 result
 169 _LayoutImpl::CheckConstruction(_Layout::Layout* pCoreLayout, _LayoutImpl* pImplLayout)
 170 {
 171         if (pImplLayout == null)
 172         {
 173                 delete pCoreLayout;
 174                 SysLogException(NID_UI, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 175                 return E_OUT_OF_MEMORY;
 176         }
 177
 178         result r = GetLastResult();
 179
 180         if (IsFailed(r))
 181         {
 182                 delete pImplLayout;
 183                 pImplLayout = null;
 184
 185                 SysLogException(NID_UI, r, "[%s] Propagating.", GetErrorMessage(r));
 186                 return r;
 187         }
 188
 189         return E_SUCCESS;
 190 }
 191
 192 _SharedPtr <_LayoutImpl>
 193 _LayoutImpl::GetLayoutImpl(Layout* pPublicLayout)
 194 {
 195         LayoutImplHolder* pHolder = static_cast <LayoutImplHolder*>(pPublicLayout->_pImpl);
 196         SysAssert(pHolder != null);
 197
 198         return pHolder->layoutImpl;
 199 }
 200
 201 void
 202 _LayoutImpl::SetLayoutImpl(Layout* pPublicLayout, _LayoutImpl* pImplLayout)
 203 {
 204         LayoutImplHolder* pHolder = static_cast <LayoutImplHolder*>(pPublicLayout->_pImpl);
 205         SysAssert(pHolder != null);
 206
 207         pHolder->layoutImpl.SetNull();
 208         pHolder->layoutImpl.Bind(pImplLayout);
 209 }
 210
 211 const char*
 212 _LayoutImpl::GetPublicClassName(void) const
 213 {
 214         return "Tizen::Ui::Layout";
 215 }
 216
 217 const Layout&
 218 _LayoutImpl::GetPublic(void) const
 219 {
 220         return *_pPublicLayout;
 221 }
 222
 223 Layout&
 224 _LayoutImpl::GetPublic(void)
 225 {
 226         return *_pPublicLayout;
 227 }
 228
 229 const _Layout::Layout&
 230 _LayoutImpl::GetCore(void) const
 231 {
 232         return *_pCoreLayout;
 233 }
 234
 235 _Layout::Layout&
 236 _LayoutImpl::GetCore(void)
 237 {
 238         return *_pCoreLayout;
 239 }
 240
 241 const _LayoutImpl*
 242 _LayoutImpl::GetInstance(const Layout& layout)
 243 {
 244         LayoutImplHolder* pHolder = static_cast <LayoutImplHolder*>(layout._pImpl);
 245         SysAssert(pHolder != null);
 246
 247         const _LayoutImpl* pImpl = pHolder->layoutImpl.Get();
 248
 249         return pImpl;
 250 }
 251
 252 _LayoutImpl*
 253 _LayoutImpl::GetInstance(Layout& layout)
 254 {
 255         LayoutImplHolder* pHolder = static_cast <LayoutImplHolder*>(layout._pImpl);
 256         SysAssert(pHolder != null);
 257
 258         _LayoutImpl* pImpl = pHolder->layoutImpl.Get();
 259
 260         return pImpl;
 261 }
 262
 263 result
 264 _LayoutImpl::SetAlignment(const _ControlImpl& item, const LayoutHorizontalAlignment horizontalAlign, const LayoutVerticalAlignment verticalAlign)
 265 {
 266         ClearLastResult();
 267
 268         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 269
 270         _Layout::ItemAlign itemAlign;
 271         itemAlign.HAlign = ConvertEnum(horizontalAlign);
 272         SysTryReturn(NID_UI, itemAlign.HAlign != (_Layout::HorizontalAlign) CONVERT_ERROR_CODE,
 273                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The given parameter is invalid.");
 274
 275         itemAlign.VAlign = ConvertEnum(verticalAlign);
 276         SysTryReturn(NID_UI, itemAlign.VAlign != (_Layout::VerticalAlign) CONVERT_ERROR_CODE,
 277                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The given parameter is invalid.");
 278
 279         return _pCoreLayout->SetItemAlignment(layoutItem, itemAlign);
 280 }
 281
 282 result
 283 _LayoutImpl::GetAlignment(const _ControlImpl& item, LayoutHorizontalAlignment& horizontalAlign, LayoutVerticalAlignment& verticalAlign) const
 284 {
 285         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 286
 287         _Layout::ItemAlign itemAlign;
 288
 289         result r = _pCoreLayout->GetItemAlignment(layoutItem, itemAlign);
 290         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 291
 292         horizontalAlign = ConvertEnum(itemAlign.HAlign);
 293         verticalAlign = ConvertEnum(itemAlign.VAlign);
 294
 295         return E_SUCCESS;
 296 }
 297
 298 result
 299 _LayoutImpl::SetMargin(const _ControlImpl& item, int left, int right, int top, int bottom)
 300 {
 301         SysTryReturn(NID_UI, left >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The left margin is negative.");
 302         SysTryReturn(NID_UI, right >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The right margin is negative.");
 303         SysTryReturn(NID_UI, top >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The top margin is negative.");
 304         SysTryReturn(NID_UI, bottom >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The bottom margin is negative.");
 305
 306         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 307
 308         _Layout::ItemMargin itemMargin;
 309
 310         itemMargin.left = left;
 311         itemMargin.right = right;
 312         itemMargin.top = top;
 313         itemMargin.bottom = bottom;
 314
 315         result r = _pCoreLayout->SetItemMargin(layoutItem, itemMargin);
 316
 317         return r;
 318 }
 319
 320 result
 321 _LayoutImpl::SetMargin(const _ControlImpl& item, float left, float right, float top, float bottom)
 322 {
 323         SysTryReturn(NID_UI, left >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The left margin is negative.");
 324         SysTryReturn(NID_UI, right >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The right margin is negative.");
 325         SysTryReturn(NID_UI, top >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The top margin is negative.");
 326         SysTryReturn(NID_UI, bottom >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The bottom margin is negative.");
 327
 328         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 329
 330         _Layout::ItemMargin itemMargin;
 331
 332         itemMargin.left = static_cast <int>(left);
 333         itemMargin.right = static_cast <int>(right);
 334         itemMargin.top = static_cast <int>(top);
 335         itemMargin.bottom = static_cast <int>(bottom);
 336
 337         result r = _pCoreLayout->SetItemMargin(layoutItem, itemMargin);
 338
 339         return r;
 340 }
 341
 342 result
 343 _LayoutImpl::GetMargin(const _ControlImpl& item, int& left, int& right, int& top, int& bottom) const
 344 {
 345         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 346
 347         _Layout::ItemMargin itemMargin;
 348
 349         result r = _pCoreLayout->GetItemMargin(layoutItem, itemMargin);
 350         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 351
 352         left = itemMargin.left;
 353         right = itemMargin.right;
 354         top = itemMargin.top;
 355         bottom = itemMargin.bottom;
 356
 357         return r;
 358 }
 359
 360 result
 361 _LayoutImpl::GetMargin(const _ControlImpl& item, float& left, float& right, float& top, float& bottom) const
 362 {
 363         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 364
 365         _Layout::ItemMargin itemMargin;
 366
 367         result r = _pCoreLayout->GetItemMargin(layoutItem, itemMargin);
 368         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 369
 370         left = static_cast <float>(itemMargin.left);
 371         right = static_cast <float>(itemMargin.right);
 372         top = static_cast <float>(itemMargin.top);
 373         bottom = static_cast <float>(itemMargin.bottom);
 374
 375         return r;
 376 }
 377
 378 result
 379 _LayoutImpl::SetHorizontalFitPolicy(const _ControlImpl& item, const FitPolicy policy)
 380 {
 381         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 382
 383         _Layout::LayoutMatchMode matchMode;
 384
 385         matchMode = ConvertEnum(policy);
 386
 387         SysTryReturn(NID_UI, matchMode != (_Layout::LayoutMatchMode) CONVERT_ERROR_CODE,
 388                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The given parameter is invalid.");
 389
 390         result r = _pCoreLayout->SetItemWidthMatchMode(layoutItem, matchMode);
 391
 392         return r;
 393 }
 394
 395 result
 396 _LayoutImpl::GetHorizontalFitPolicy(const _ControlImpl& item, FitPolicy& policy) const
 397 {
 398         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 399
 400         _Layout::LayoutMatchMode matchMode;
 401
 402         result r = _pCoreLayout->GetItemWidthMatchMode(layoutItem, matchMode);
 403         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 404
 405         policy = ConvertEnum(matchMode);
 406
 407         return r;
 408 }
 409
 410 result
 411 _LayoutImpl::SetVerticalFitPolicy(const _ControlImpl& item, const FitPolicy matchMode)
 412 {
 413         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 414
 415         _Layout::LayoutMatchMode layoutMatchMode;
 416
 417         layoutMatchMode = ConvertEnum(matchMode);
 418
 419         SysTryReturn(NID_UI, layoutMatchMode != (_Layout::LayoutMatchMode) CONVERT_ERROR_CODE,
 420                                 E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The given parameter is invalid.");
 421
 422         result r = _pCoreLayout->SetItemHeightMatchMode(layoutItem, layoutMatchMode);
 423
 424         return r;
 425 }
 426
 427 result
 428 _LayoutImpl::GetVerticalFitPolicy(const _ControlImpl& item, FitPolicy& policy) const
 429 {
 430         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 431
 432         _Layout::LayoutMatchMode matchMode;
 433
 434         result r = _pCoreLayout->GetItemHeightMatchMode(layoutItem, matchMode);
 435         SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 436
 437         policy = ConvertEnum(matchMode);
 438
 439         return r;
 440 }
 441
 442 result
 443 _LayoutImpl::UpdateLayout(void)
 444 {
 445         result r = _pCoreLayout->UpdateLayout();
 446
 447         return r;
 448 }
 449
 450 result
 451 _LayoutImpl::AddItem(_ControlImpl& addItem)
 452 {
 453         _Layout::LayoutItem& layoutItem = addItem.GetLayoutContainer();
 454
 455         result r = _pCoreLayout->AddItem(layoutItem);
 456
 457         return r;
 458 }
 459
 460 result
 461 _LayoutImpl::RemoveItem(const _ControlImpl& removeItem)
 462 {
 463         _Layout::LayoutItem& layoutItem = removeItem.GetLayoutContainer();
 464
 465         result r = _pCoreLayout->RemoveItem(layoutItem);
 466
 467         return r;
 468 }
 469
 470 result
 471 _LayoutImpl::OnChangeViewPos(int viewPosX, int viewPosY)
 472 {
 473         result r = _pCoreLayout->OnChangeViewPosition(viewPosX, viewPosY);
 474
 475         return r;
 476 }
 477
 478 result
 479 _LayoutImpl::SetItemBaseRect(const _ControlImpl& item, const _Layout::LayoutRect baseRect)
 480 {
 481         SysTryReturn(NID_UI, baseRect.x >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] X position is negative.");
 482         SysTryReturn(NID_UI, baseRect.y >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Y position is negative.");
 483         SysTryReturn(NID_UI, baseRect.w >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Width is negative.");
 484         SysTryReturn(NID_UI, baseRect.h >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] Height is negative.");
 485
 486         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 487
 488         result r = _pCoreLayout->SetItemBaseRect(layoutItem, baseRect);
 489
 490         return r;
 491 }
 492
 493 result
 494 _LayoutImpl::GetItemBaseRect(const _ControlImpl& item, _Layout::LayoutRect& baseRect) const
 495 {
 496         _Layout::LayoutItem& layoutItem = item.GetLayoutContainer();
 497
 498         result r = _pCoreLayout->GetItemBaseRect(layoutItem, baseRect);
 499
 500         return r;
 501 }
 502
 503 void
 504 _LayoutImpl::AllocateLayoutImpl(Layout* pPublicLayout, _SharedPtr <Tizen::Ui::_LayoutImpl> layoutImpl)
 505 {
 506         LayoutImplHolder* pHolder = static_cast <LayoutImplHolder*>(pPublicLayout->_pImpl);
 507         SysAssert(pHolder != null);
 508
 509         pHolder->layoutImpl = layoutImpl;
 510 }
 511
 512 Layout*
 513 _LayoutImpl::CreatePublicLayoutN(_SharedPtr <Tizen::Ui::_LayoutImpl> layoutImpl)
 514 {
 515         _LayoutImpl* pLayoutImpl = layoutImpl.Get();
 516         if (pLayoutImpl == null)
 517         {
 518                 return null;
 519         }
 520
 521         switch (pLayoutImpl->GetLayoutType())
 522         {
 523         case LAYOUT_RELATIVE:
 524         {
 525                 RelativeLayout* pPublicLayout = new (std::nothrow) RelativeLayout;
 526                 SysTryReturn(NID_UI, pPublicLayout != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 527
 528                 _LayoutImpl::AllocateLayoutImpl(pPublicLayout, layoutImpl);
 529
 530                 return pPublicLayout;
 531         }
 532
 533         case LAYOUT_VERTICAL_BOX:
 534         {
 535                 VerticalBoxLayout* pPublicLayout = new (std::nothrow) VerticalBoxLayout;
 536                 SysTryReturn(NID_UI, pPublicLayout != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 537
 538                 _LayoutImpl::AllocateLayoutImpl(pPublicLayout, layoutImpl);
 539
 540                 return pPublicLayout;
 541         }
 542
 543         case LAYOUT_HORIZONTAL_BOX:
 544         {
 545                 HorizontalBoxLayout* pPublicLayout = new (std::nothrow) HorizontalBoxLayout;
 546                 SysTryReturn(NID_UI, pPublicLayout != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 547
 548                 _LayoutImpl::AllocateLayoutImpl(pPublicLayout, layoutImpl);
 549
 550                 return pPublicLayout;
 551         }
 552
 553         case LAYOUT_GRID:
 554         {
 555                 GridLayout* pPublicLayout = new (std::nothrow) GridLayout;
 556                 SysTryReturn(NID_UI, pPublicLayout != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 557
 558                 _LayoutImpl::AllocateLayoutImpl(pPublicLayout, layoutImpl);
 559
 560                 return pPublicLayout;
 561         }
 562
 563         case LAYOUT_CARD:
 564         {
 565                 CardLayout* pPublicLayout = new (std::nothrow) CardLayout;
 566                 SysTryReturn(NID_UI, pPublicLayout != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
 567
 568                 _LayoutImpl::AllocateLayoutImpl(pPublicLayout, layoutImpl);
 569
 570                 return pPublicLayout;
 571         }
 572
 573         default:
 574                 SysAssert(false);
 575                 return null;
 576         }
 577         return null;
 578 }
 579
 580 }} // Tizen::Ui