src/ui/controls/FUiCtrl_PopupImpl.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_PopupImpl.cpp
  20  * @brief       This is the implementation file for the _PopupImpl class.
  21  */
  22
  23
  24 #include <FUiLayout.h>
  25 #include <FBaseSysLog.h>
  26 #include <FUiAccessibilityContainer.h>
  27 #include <FUiAccessibilityElement.h>
  28 #include "FUi_CoordinateSystemUtils.h"
  29 #include "FUi_UiBuilder.h"
  30 #include "FUi_DataBindingContextImpl.h"
  31 #include "FUi_ResourceSizeInfo.h"
  32 #include "FUi_ResourceManager.h"
  33 #include "FUi_ControlImplManager.h"
  34 #include "FUi_LayoutImpl.h"
  35 #include "FUi_Math.h"
  36 #include "FUiCtrl_FrameImpl.h"
  37 #include "FUiCtrl_PopupImpl.h"
  38 #include "FUiCtrl_Popup.h"
  39 #include "FUiCtrl_Form.h"
  40 #include "FUiCtrl_Indicator.h"
  41
  42
  43 using namespace Tizen::Ui::Animations;
  44 using namespace Tizen::Graphics;
  45 using namespace Tizen::Ui;
  46
  47
  48 namespace Tizen { namespace Ui { namespace Controls
  49 {
  50
  51
  52 FloatDimension
  53 _PopupImpl::PopupSizeInfo::GetDefaultMinimumSizeF(_ControlOrientation orientation) const
  54 {
  55         result r = E_SUCCESS;
  56         FloatDimension dimension(0, 0);
  57
  58         r = GET_DIMENSION_CONFIG(POPUP::MIN_SIZE, orientation, dimension);
  59         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, dimension, r, "[%s] A system error occurred.", GetErrorMessage(r));
  60         SetLastResult(r);
  61
  62         return dimension;
  63 }
  64
  65 _PopupImpl*
  66 _PopupImpl::GetInstance(Popup& pPopup)
  67 {
  68         return static_cast <_PopupImpl*>(pPopup._pControlImpl);
  69 }
  70
  71 const _PopupImpl*
  72 _PopupImpl::GetInstance(const Popup& pPopup)
  73 {
  74         return static_cast <const _PopupImpl*>(pPopup._pControlImpl);
  75 }
  76
  77 _PopupImpl::_PopupImpl(Popup* pPublic, _Popup* pCore, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
  78         : _WindowImpl(pPublic, pCore, pPublicPortraitLayout, pPublicLandscapeLayout)
  79         , _isModal(false)
  80         , _centerAlign(false)
  81         , __init(false)
  82         , __callBoundsChange(false)
  83         , __prevPos(0.0f, 0.0f)
  84 {
  85         //empty statement
  86 }
  87
  88 _PopupImpl::~_PopupImpl(void)
  89 {
  90         //empty statement
  91 }
  92
  93 _PopupImpl*
  94 _PopupImpl::CreatePopupImplN(Popup* pControl, const Tizen::Graphics::FloatDimension& dim, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
  95 {
  96         result r = E_SUCCESS;
  97
  98         r = GET_SIZE_INFO(Popup).CheckInitialSizeValidF(dim, _CONTROL_ORIENTATION_PORTRAIT);
  99         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] The given size is not valid.");
 100
 101         _PopupImpl* pImpl = null;
 102         _Popup* pCore = null;
 103
 104         pCore = _Popup::CreatePopupN();
 105         SysTryReturn(NID_UI_CTRL, pCore, null, E_SYSTEM, "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 106
 107         pImpl = new (std::nothrow) _PopupImpl(pControl, pCore, pPublicPortraitLayout, pPublicLandscapeLayout);
 108         r = CheckConstruction(pCore, pImpl);
 109         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 110
 111         r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(Popup), dim, pCore->GetOrientation());
 112         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 113
 114         ClearLastResult();
 115
 116         return pImpl;
 117
 118 CATCH:
 119         delete pImpl;   //This deletes pCore as well
 120
 121         return null;
 122 }
 123
 124 result
 125 _PopupImpl::Initialize(bool hasTitle, const Tizen::Graphics::FloatDimension& dim)
 126 {
 127         result r = E_SUCCESS;
 128
 129         FloatRectangle bounds = GetCenterAlignedRect(dim.width, dim.height);
 130         __init = true;
 131         _centerAlign = true;
 132
 133         r = SetBounds(bounds);
 134         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 135
 136         return GetCore().Initialize(hasTitle, bounds);
 137 }
 138
 139 const char*
 140 _PopupImpl::GetPublicClassName(void) const
 141 {
 142         return "Tizen::Ui::Controls::Popup";
 143 }
 144
 145 const Popup&
 146 _PopupImpl::GetPublic(void) const
 147 {
 148         return static_cast <const Popup&>(_ControlImpl::GetPublic());
 149 }
 150
 151 Popup&
 152 _PopupImpl::GetPublic(void)
 153 {
 154         return static_cast <Popup&>(_ControlImpl::GetPublic());
 155 }
 156
 157 const _Popup&
 158 _PopupImpl::GetCore(void) const
 159 {
 160         return static_cast <const _Popup&>(_ControlImpl::GetCore());
 161 }
 162
 163 _Popup&
 164 _PopupImpl::GetCore(void)
 165 {
 166         return static_cast <_Popup&>(_ControlImpl::GetCore());
 167 }
 168
 169 FloatRectangle
 170 _PopupImpl::GetCenterAlignedRect(float width, float height) const
 171 {
 172         float x = 0.0f;
 173         float y = 0.0f;
 174
 175         _ControlManager* pControlManager = _ControlManager::GetInstance();
 176
 177         FloatDimension screenRect = pControlManager->GetScreenSizeF();
 178
 179         if (GetCore().GetOrientation() == _CONTROL_ORIENTATION_LANDSCAPE)
 180         {
 181                 float temp = screenRect.width;
 182                 screenRect.width = screenRect.height;
 183                 screenRect.height = temp;
 184         }
 185
 186         x = (screenRect.width - width) / 2.0f;
 187         y = (screenRect.height - height) / 2.0f;
 188
 189         return FloatRectangle(x, y, width, height);
 190 }
 191
 192 FloatRectangle
 193 _PopupImpl::GetClientAreaBounds(void) const
 194 {
 195         return CoordinateSystem::AlignToDevice(_ControlImpl::GetClientBoundsF());
 196 }
 197
 198 Canvas*
 199 _PopupImpl::GetClientAreaCanvasN(void) const
 200 {
 201         return GetCore().GetClientAreaCanvasN();
 202 }
 203
 204 FloatPoint
 205 _PopupImpl::TranslateFromClientAreaPosition(const FloatPoint& clientPosition) const
 206 {
 207         return GetCore().TranslateFromClientAreaPosition(clientPosition);
 208 }
 209
 210 FloatPoint
 211 _PopupImpl::TranslateToClientAreaPosition(const FloatPoint& position) const
 212 {
 213         return GetCore().TranslateToClientAreaPosition(position);
 214 }
 215
 216 result
 217 _PopupImpl::DoModal(int& modalResult)
 218 {
 219         SysTryReturn(NID_UI_CTRL, GetVisibleState() != false, E_INVALID_STATE,
 220                                         E_INVALID_STATE, "[E_INVALID_STATE] The Popup is not visible");
 221
 222         _isModal = true;
 223
 224         return GetCore().DoModal(modalResult);
 225 }
 226
 227 result
 228 _PopupImpl::EndModal(int modalResult)
 229 {
 230         SysTryReturn(NID_UI_CTRL, _isModal == true, E_INVALID_STATE, E_INVALID_STATE,
 231                                 "[E_INVALID_STATE] The method is not supported because this popup isn't running as a modal window.");
 232
 233         return GetCore().EndModal(modalResult);
 234 }
 235
 236 result
 237 _PopupImpl::SetColor(const Color& color)
 238 {
 239         GetCore().SetColor(color);
 240
 241         return E_SUCCESS;
 242 }
 243
 244 Color
 245 _PopupImpl::GetColor(void) const
 246 {
 247         return GetCore().GetColor();
 248 }
 249
 250 result
 251 _PopupImpl::SetTitleText(const Tizen::Base::String& title)
 252 {
 253         result r = GetCore().SetTitleText(title);
 254         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, r, "[%s] Propagating.", GetErrorMessage(r));
 255
 256         return r;
 257 }
 258
 259 Tizen::Base::String
 260 _PopupImpl::GetTitleText(void) const
 261 {
 262         return GetCore().GetTitleText();
 263 }
 264
 265 result
 266 _PopupImpl::SetTitleTextColor(const Color& color)
 267 {
 268         GetCore().SetTitleTextColor(color);
 269
 270         return E_SUCCESS;
 271 }
 272
 273 Color
 274 _PopupImpl::GetTitleTextColor() const
 275 {
 276         return GetCore().GetTitleTextColor();
 277 }
 278
 279 DataBindingContext*
 280 _PopupImpl::GetDataBindingContextN(void) const
 281 {
 282         return Tizen::Ui::_DataBindingContextImpl::GetDataBindingContextN(*this);
 283 }
 284
 285 bool
 286 _PopupImpl::GetXmlBounds(Tizen::Graphics::FloatRectangle& rect)
 287 {
 288         Rectangle builderBounds;
 289         _ControlOrientation controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
 290         bool exist = GetBuilderBounds(controlOrientation, builderBounds);
 291         if(!exist)
 292         {
 293                 return false;
 294         }
 295
 296         controlOrientation = GetCore().GetOrientation();
 297
 298         if (controlOrientation == _CONTROL_ORIENTATION_LANDSCAPE)
 299         {
 300                 exist = GetBuilderBounds(controlOrientation, builderBounds);
 301         }
 302         rect = _CoordinateSystemUtils::ConvertToFloat(builderBounds);
 303
 304         return true;
 305 }
 306 void
 307 _PopupImpl::OnChangeLayout(_ControlOrientation orientation)
 308 {
 309         result r = E_SUCCESS;
 310         FloatRectangle bounds;
 311         if (!__callBoundsChange)
 312         {
 313                 _centerAlign = true;
 314
 315                 if(GetXmlBounds(bounds))
 316                 {
 317                         bounds = GetCenterAlignedRect(bounds.width, bounds.height);
 318                 }
 319                 else
 320                 {
 321                         bounds = GetCenterAlignedRect(GetBounds().width, GetBounds().height);
 322                 }
 323                 r = SetBounds(bounds);
 324                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 325         }
 326         else
 327         {
 328                 if(GetXmlBounds(bounds))
 329                 {
 330                         r = SetBounds(bounds);
 331                 }
 332                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 333
 334         }
 335
 336         Layout* pLayout;
 337
 338         pLayout = GetPublicLayoutN();
 339
 340         if (pLayout != null)
 341         {
 342                 Tizen::Ui::_SharedPtr<Tizen::Ui::_LayoutImpl> pLayoutImpl = _LayoutImpl::GetLayoutImpl(pLayout);
 343
 344                 if (!pLayoutImpl.IsNull())
 345                 {
 346                         r = GetCore().SetCurrentLayout(pLayoutImpl->GetCore());
 347                         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Failed to set up the current layout");
 348                 }
 349         }
 350
 351         return GetCore().OnChangeLayout(orientation);
 352 }
 353
 354 result
 355 _PopupImpl::OnBoundsChanging(const FloatRectangle& bounds)
 356 {
 357         __prevPos = GetBoundsF().GetTopLeft();
 358
 359         return _ControlImpl::OnBoundsChanging(bounds);
 360 }
 361
 362 void
 363 _PopupImpl::OnBoundsChanged(void)
 364 {
 365         FloatRectangle rect = GetBoundsF();
 366         if (__init)
 367         {
 368                 if ((_centerAlign || (_FloatCompare(__prevPos.x, rect.x) && _FloatCompare(__prevPos.y, rect.y))) && __callBoundsChange == false)
 369                 {
 370                         rect = GetCenterAlignedRect(GetSizeF().width, GetSizeF().height);
 371                 }
 372                 else
 373                 {
 374                         __callBoundsChange = true;
 375                 }
 376         }
 377
 378         _centerAlign = true;
 379
 380         result r = SetBounds(rect, true);
 381         if (IsFailed(r))
 382         {
 383                 // Error propagation fall through
 384                 ClearLastResult();
 385         }
 386
 387         _ControlImpl::OnBoundsChanged();
 388
 389         _centerAlign = false;
 390 }
 391
 392
 393 class _PopupMaker
 394         : public _UiBuilderControlMaker
 395 {
 396 public:
 397         _PopupMaker(_UiBuilder* uibuilder)
 398                 : _UiBuilderControlMaker(uibuilder){};
 399         virtual ~_PopupMaker(){};
 400
 401         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
 402         {
 403                 _PopupMaker* pPopupMaker = new (std::nothrow) _PopupMaker(uibuilder);
 404
 405                 return static_cast<_UiBuilderControlMaker*>(pPopupMaker);
 406         };
 407
 408 protected:
 409         virtual Tizen::Ui::Control* Make(_UiBuilderControl* pControl)
 410         {
 411                 bool hasTitle = false;
 412                 result r = E_SYSTEM;
 413                 _UiBuilderControlLayout* pControlProperty = null;
 414                 Tizen::Base::String elementString;
 415                 Color color;
 416                 Tizen::Graphics::FloatDimension dim;
 417                 Tizen::Graphics::FloatRectangle rect;
 418
 419                 Popup* pPopup = dynamic_cast <Popup*>(GetContainer());
 420                 SysTryReturn(NID_UI_CTRL, pPopup != null, null, E_SYSTEM, "[E_SYSTEM] This instance is not constructed.");
 421
 422                 SetUiBuilderRotateState(UIBUIDER_SCREEN_VERTICAL);
 423                 GetProperty(pControl, &pControlProperty);
 424
 425                 if (pControlProperty == null)
 426                 {
 427                         return null;
 428                 }
 429
 430                 if (pControl->GetElement("titleText", elementString))
 431                 {
 432                         hasTitle = true;
 433                 }
 434                 else
 435                 {
 436                         hasTitle = false;
 437                 }
 438
 439                 //pPopup = new (std::nothrow) Popup();
 440                 rect = pControlProperty->GetRectF();
 441
 442                 dim.width = rect.width;
 443                 dim.height = rect.height;
 444
 445                 _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
 446                 __pLayoutMaker->GetLayoutType(pControlProperty, layoutType);
 447
 448                 if (layoutType == UIBUILDER_LAYOUT_NONE)
 449                 {
 450                         r = pPopup->Construct(hasTitle, dim);
 451                 }
 452                 else
 453                 {
 454                         Layout* pPortraitLayout = null;
 455                         Layout* pLandscapeLayout = null;
 456                         result tempResult = E_SUCCESS;
 457
 458                         tempResult = __pLayoutMaker->GetLayoutN(pControl, pPortraitLayout, pLandscapeLayout);
 459
 460                         if (E_SUCCESS == tempResult)
 461                         {
 462                                 r = pPopup->Construct(*pPortraitLayout, *pLandscapeLayout, hasTitle, dim);
 463                         }
 464                         else
 465                         {
 466                                 r = tempResult;
 467                         }
 468
 469                         _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
 470
 471                         if (__pLayoutMaker->GetLayoutType(pControlProperty, layoutType) == false)
 472                         {
 473                                 return null;
 474                         }
 475
 476                         if ( layoutType == UIBUILDER_LAYOUT_GRID)
 477                         {
 478                                 for (int i = 0; i < UIBUILDER_ATTRIBUTE_NUM; i++)
 479                                 {
 480                                         GridLayout* pGridLayout = null;
 481                                         pControlProperty = pControl->GetAttribute(i);
 482
 483                                         if ( i == UIBUILDER_ATTRIBUTE_PORTRAIT)
 484                                         {
 485                                                 pGridLayout = dynamic_cast<GridLayout*>(pPortraitLayout);
 486                                         }
 487                                         else
 488                                         {
 489                                                 pGridLayout = dynamic_cast<GridLayout*>(pLandscapeLayout);
 490                                         }
 491                                         __pLayoutMaker->SetGridLayoutContainerProperty(pGridLayout, pControlProperty);
 492                                 }
 493                         }
 494
 495                         delete pPortraitLayout;
 496
 497                         if (pPortraitLayout != pLandscapeLayout)
 498                         {
 499                                 delete pLandscapeLayout;
 500                         }
 501                 //      CONSTRUCT_WITH_LAYOUT_ARG2(pPopup, hasTitle, dim);
 502                 }
 503
 504                 if (r != E_SUCCESS)
 505                 {
 506                         SysLog(NID_UI_CTRL, "Failed to create Popup.");
 507                         return null;
 508                 }
 509
 510                 if (hasTitle == true)
 511                 {
 512                         pPopup->SetTitleText(elementString);
 513                 }
 514
 515                 //set property
 516                 if (pControl->GetElement("color", elementString))
 517                 {
 518                         ConvertStringToColor(elementString, color);
 519                         pPopup->SetColor(color);
 520                 }
 521
 522                 if (pControl->GetElement("titleTextColor", elementString))
 523                 {
 524                         ConvertStringToColor(elementString, color);
 525                         pPopup->SetTitleTextColor(color);
 526                 }
 527
 528                 if (pControl->GetElement(L"accessibilityHint", elementString))
 529                 {
 530                         AccessibilityContainer* pContainer = pPopup->GetAccessibilityContainer();
 531                         if (pContainer)
 532                         {
 533                                 AccessibilityElement* pElement = pContainer->GetElement(L"PopupTitleText");
 534                                 if (pElement)
 535                                 {
 536                                         pElement->SetHint(elementString);
 537                                 }
 538                         }
 539                 }
 540
 541                 return pPopup;
 542         }
 543
 544 private:
 545
 546 };      // _PopupMaker
 547
 548 _PopupRegister::_PopupRegister()
 549 {
 550         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 551         pUiBuilderControlTableManager->RegisterControl(L"Popup", _PopupMaker::GetInstance);
 552 }
 553
 554 _PopupRegister::~_PopupRegister()
 555 {
 556         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 557         pUiBuilderControlTableManager->UnregisterControl(L"Popup");
 558 }
 559 static _PopupRegister PopupRegisterToUiBuilder;
 560
 561 }}} // Tizen::Ui::Controls