src/ui/controls/FUiCtrl_PanelImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
  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_PanelImpl.cpp
  20  * @brief       This is the implementation file for the %_PanelImpl class.
  21  *
  22  */
  23
  24 #include <FBaseErrors.h>
  25 #include <FUiLayout.h>
  26 #include <FBaseSysLog.h>
  27 #include "FUi_LayoutImpl.h"
  28 #include "FUi_DataBindingContextImpl.h"
  29 #include "FUi_UiBuilder.h"
  30 #include "FUiCtrl_PanelImpl.h"
  31 #include "FUiCtrl_FormImpl.h"
  32
  33 using namespace Tizen::Graphics;
  34
  35 namespace Tizen { namespace Ui { namespace Controls
  36 {
  37
  38 _PanelImpl::_PanelImpl(Control* pPublic, _Control* pCore, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
  39         : _ContainerImpl(pPublic, pCore, pPublicPortraitLayout, pPublicLandscapeLayout)
  40 {
  41         // nothing
  42 }
  43
  44 _PanelImpl::~_PanelImpl(void)
  45 {
  46         // nothing
  47 }
  48
  49 _PanelImpl*
  50 _PanelImpl::CreatePanelImplN(Panel* pControl, const Rectangle& rect, GroupStyle groupStyle, Layout* pPublicPortraitLayout, Layout* pPublicLandscapeLayout)
  51 {
  52         ClearLastResult();
  53
  54         _PanelImpl* pImpl = null;
  55         _Panel* pCore = null;
  56
  57         if (pPublicPortraitLayout != null)
  58         {
  59                 _LayoutImpl* pPortraitLayoutImpl = _LayoutImpl::GetInstance(*pPublicPortraitLayout);
  60                 SysTryReturn(NID_UI_CTRL, pPortraitLayoutImpl != null, null, E_INVALID_ARG, "[%s] Portrait layout is invalid object.", GetErrorMessage(E_INVALID_ARG));
  61         }
  62
  63         if (pPublicLandscapeLayout != null)
  64         {
  65                 _LayoutImpl* pLandscapeLayoutImpl = _LayoutImpl::GetInstance(*pPublicLandscapeLayout);
  66                 SysTryReturn(NID_UI_CTRL, pLandscapeLayoutImpl != null, null, E_INVALID_ARG, "[%s] Landscape layout is invalid object", GetErrorMessage(E_INVALID_ARG));
  67         }
  68
  69         pCore = _Panel::CreatePanelN(rect, groupStyle);
  70         result r = GetLastResult();
  71         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  72
  73         pImpl = new (std::nothrow) _PanelImpl(pControl, pCore, pPublicPortraitLayout, pPublicLandscapeLayout);
  74         r = CheckConstruction(pCore, pImpl);
  75         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  76
  77         r = pImpl->SetBounds(rect);
  78         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
  79
  80         return pImpl;
  81
  82 CATCH:
  83         delete pImpl;
  84
  85         SetLastResult(r);
  86         return null;
  87 }
  88
  89 const _PanelImpl*
  90 _PanelImpl::GetInstance(const Panel& panel)
  91 {
  92         return static_cast<const _PanelImpl*>(_ControlImpl::GetInstance(panel));
  93 }
  94
  95 _PanelImpl*
  96 _PanelImpl::GetInstance(Panel& panel)
  97 {
  98         return static_cast<_PanelImpl*>(_ControlImpl::GetInstance(panel));
  99 }
 100
 101 const char*
 102 _PanelImpl::GetPublicClassName(void) const
 103 {
 104         return "Tizen::Ui::Controls::Panel";
 105 }
 106
 107 const Panel&
 108 _PanelImpl::GetPublic(void) const
 109 {
 110         return static_cast <const Panel&>(_ControlImpl::GetPublic());
 111 }
 112
 113 Panel&
 114 _PanelImpl::GetPublic(void)
 115 {
 116         return static_cast <Panel&>(_ControlImpl::GetPublic());
 117 }
 118
 119 const _Panel&
 120 _PanelImpl::GetCore(void) const
 121 {
 122         return static_cast <const _Panel&>(_ControlImpl::GetCore());
 123 }
 124
 125 _Panel&
 126 _PanelImpl::GetCore(void)
 127 {
 128         return static_cast <_Panel&>(_ControlImpl::GetCore());
 129 }
 130
 131 void
 132 _PanelImpl::SetBackgroundColor(const Tizen::Graphics::Color& color)
 133 {
 134         if (!IsOpaque())
 135         {
 136                 GetCore().SetBackgroundColor(color);
 137         }
 138         else
 139         {
 140                 byte r, g, b, a;
 141                 color.GetColorComponents(r, g, b, a);
 142                 GetCore().SetBackgroundColor(Color(r*a/ 255, g*a/255, b*a/ 255, 255));
 143         }
 144 }
 145
 146 bool
 147 _PanelImpl::IsCompositeEnabled(void) const
 148 {
 149         ClearLastResult();
 150         return true;
 151 }
 152
 153 result
 154 _PanelImpl::SetCompositeEnabled(bool enabled)
 155 {
 156         ClearLastResult();
 157
 158         if (enabled)
 159         {
 160                 return E_SUCCESS;
 161         }
 162
 163         SysLogException(NID_UI, E_SYSTEM, "[%s] This method is not supported.", GetErrorMessage(E_SYSTEM));
 164         return E_SYSTEM;
 165 }
 166
 167 result
 168 _PanelImpl::OnAttachedToMainTree(void)
 169 {
 170         SetFocusable(false);
 171
 172         Rectangle builderBounds;
 173         _ControlOrientation controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
 174         bool exist = GetBuilderBounds(controlOrientation, builderBounds);
 175
 176         if (exist)
 177         {
 178                 _ContainerImpl* pContainerImpl = this;
 179                 _FormImpl* pParentImpl = null;
 180
 181                 while(pContainerImpl)
 182                 {
 183                         pParentImpl = dynamic_cast<_FormImpl*>(pContainerImpl->GetParent());
 184
 185                         if (pParentImpl != null)
 186                         {
 187                                 break;
 188                         }
 189                         else
 190                         {
 191                                 pContainerImpl = pContainerImpl->GetParent();
 192                         }
 193                 }
 194
 195                 if (pParentImpl)
 196                 {
 197                         OrientationStatus orientation = pParentImpl->GetOrientationStatus();
 198                         if (orientation == ORIENTATION_STATUS_LANDSCAPE
 199                                 || orientation == ORIENTATION_STATUS_LANDSCAPE_REVERSE)
 200                         {
 201                                 controlOrientation = _CONTROL_ORIENTATION_LANDSCAPE;
 202                                 GetBuilderBounds(controlOrientation, builderBounds);
 203                         }
 204                         SetBounds(builderBounds);
 205                         SetChildBuilderBouds(this, controlOrientation);
 206                 }
 207         }
 208
 209         _ContainerImpl::OnAttachedToMainTree();
 210
 211         return E_SUCCESS;
 212 }
 213
 214 void
 215 _PanelImpl::SetChildBuilderBouds(_ContainerImpl* pContainerImpl, _ControlOrientation controlOrientation)
 216 {
 217         Rectangle builderBounds;
 218         _ContainerImpl* pTempContainerImpl;
 219         for(int i = 0; i < pContainerImpl->GetChildCount(); i++)
 220         {
 221                 _ControlImpl* pControlImpl =  pContainerImpl->GetChild(i);
 222                 pControlImpl->GetBuilderBounds(controlOrientation, builderBounds);
 223                 pControlImpl->SetBounds(builderBounds);
 224                 pTempContainerImpl = dynamic_cast<_ContainerImpl*>(pControlImpl);
 225                 if (pTempContainerImpl != null)
 226                 {
 227                         SetChildBuilderBouds(pTempContainerImpl, controlOrientation);
 228                 }
 229
 230         }
 231 }
 232
 233
 234 DataBindingContext*
 235 _PanelImpl::GetDataBindingContextN(void) const
 236 {
 237         return _DataBindingContextImpl::GetDataBindingContextN(*this);
 238 }
 239
 240 class _PanelMaker
 241         : public _UiBuilderControlMaker
 242 {
 243 public:
 244         _PanelMaker(_UiBuilder* uibuilder)
 245                 : _UiBuilderControlMaker(uibuilder){};
 246         virtual ~_PanelMaker(void){};
 247         static _UiBuilderControlMaker*
 248         GetInstance(_UiBuilder* uibuilder)
 249         {
 250                 _PanelMaker* pPanelMaker = new (std::nothrow) _PanelMaker(uibuilder);
 251                 SysTryReturn(NID_UI_CTRL, pPanelMaker != null, null, E_OUT_OF_MEMORY, "[%s] The memory is insufficient.", GetErrorMessage(E_OUT_OF_MEMORY));
 252
 253                 return pPanelMaker;
 254         };
 255 protected:
 256         virtual Control*
 257         Make(_UiBuilderControl* pControl)
 258         {
 259                 result r = E_SYSTEM;
 260                 _UiBuilderControlLayout* pControlProperty = null;
 261                 Panel* pPanel = null;
 262                 Rectangle rect;
 263                 Tizen::Base::String elementString;
 264                 int opacity = 0;
 265                 Color color;
 266                 GroupStyle panelGroupStyle = GROUP_STYLE_NONE;
 267
 268                 GetProperty(pControl, &pControlProperty);
 269                 if (pControlProperty == null)
 270                 {
 271                         return null;
 272                 }
 273
 274                 if(pControl->GetParentWin().IsEmpty())
 275                 {
 276                         pPanel = static_cast<Panel*> (GetContainer());
 277                 }
 278                 else
 279                 {
 280                         pPanel = new (std::nothrow) Panel();
 281                 }
 282                 SysTryReturn(NID_UI_CTRL, pPanel != null, null, E_OUT_OF_MEMORY, "[%s] UiBuilder failed to create Panel object.", GetErrorMessage(E_OUT_OF_MEMORY));
 283                 rect = pControlProperty->GetRect();
 284
 285                 if (pControl->GetElement(L"groupStyle", elementString) || pControl->GetElement(L"GroupStyle", elementString))
 286                 {
 287                         if (elementString.Equals(L"GROUP_STYLE_NONE", false))
 288                         {
 289                                 panelGroupStyle = GROUP_STYLE_NONE;
 290                         }
 291                         if (elementString.Equals(L"GROUP_STYLE_SINGLE", false))
 292                         {
 293                                 panelGroupStyle = GROUP_STYLE_SINGLE;
 294                         }
 295                         if (elementString.Equals(L"GROUP_STYLE_TOP", false))
 296                         {
 297                                 panelGroupStyle = GROUP_STYLE_TOP;
 298                         }
 299                         if (elementString.Equals(L"GROUP_STYLE_MIDDLE", false))
 300                         {
 301                                 panelGroupStyle = GROUP_STYLE_MIDDLE;
 302                         }
 303                         if (elementString.Equals(L"GROUP_STYLE_BOTTOM", false))
 304                         {
 305                                 panelGroupStyle = GROUP_STYLE_BOTTOM;
 306                         }
 307                 }
 308
 309                 // Construct
 310                 _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
 311                 GetLayoutType(pControlProperty, layoutType);
 312                 if (layoutType == UIBUILDER_LAYOUT_NONE)
 313                 {
 314                         r = pPanel->Construct(rect, panelGroupStyle);
 315                 }
 316                 else
 317                 {
 318                         Layout* pPortraitLayout = null;
 319                         Layout* pLandscapeLayout = null;
 320                         result tempResult = E_SUCCESS;
 321                         tempResult = GetLayoutN(pControl, pPortraitLayout, pLandscapeLayout);
 322                         if (E_SUCCESS == tempResult)
 323                         {
 324                                 r = pPanel->Construct(*pPortraitLayout, *pLandscapeLayout, rect, panelGroupStyle);
 325                         }
 326                         else
 327                         {
 328                                 r = tempResult;
 329                         }
 330                         _UiBuilderLayoutType layoutType = UIBUILDER_LAYOUT_NONE;
 331
 332                         if (GetLayoutType(pControlProperty, layoutType) == false)
 333                         {
 334                                 delete pPanel;
 335                                 return null;
 336                         }
 337
 338                         if ( layoutType == UIBUILDER_LAYOUT_GRID)
 339                         {
 340                                 for (int i = 0; i < UIBUILDER_ATTRIBUTE_NUM; i++)
 341                                 {
 342                                         GridLayout* pGridLayout = null;
 343                                         pControlProperty = pControl->GetAttribute(i);
 344
 345                                         if ( i == UIBUILDER_ATTRIBUTE_PORTRAIT)
 346                                         {
 347                                                 pGridLayout = dynamic_cast<GridLayout*>(pPortraitLayout);
 348                                         }
 349                                         else
 350                                         {
 351                                                 pGridLayout = dynamic_cast<GridLayout*>(pLandscapeLayout);
 352                                         }
 353                                         SetGridLayoutContainerProperty(pGridLayout, pControlProperty);
 354                                 }
 355                         }
 356                         delete pPortraitLayout;
 357                         if (pPortraitLayout != pLandscapeLayout)
 358                         {
 359                                 delete pLandscapeLayout;
 360                         }
 361                         //CONSTRUCT_WITH_LAYOUT_ARG2(pPanel, rect, gStyle);
 362                 }
 363                 if (r != E_SUCCESS)
 364                 {
 365                         delete pPanel;
 366                         return null;
 367                 }
 368
 369                 if (pControl->GetElement(L"backgroundOpacity", elementString) || pControl->GetElement(L"BGColorOpacity", elementString) || pControl->GetElement(L"backgroundColorOpacity", elementString))
 370                 {
 371                         Base::Integer::Parse(elementString, opacity);
 372                 }
 373                 if (pControl->GetElement(L"backgroundColor", elementString) || pControl->GetElement(L"BGColor", elementString))
 374                 {
 375                         ConvertStringToColor32(elementString, opacity, color);
 376                         pPanel->SetBackgroundColor(color);
 377                 }
 378                 else
 379                 {
 380                         color = pPanel->GetBackgroundColor();
 381                         color.SetAlpha(ConvertOpacity100to255(opacity));
 382                         pPanel->SetBackgroundColor(color);
 383                 }
 384
 385                 // set composite mode
 386                 if (pControl->GetElement(L"compositeEnabled", elementString))
 387                 {
 388                         if (elementString.Equals(L"false", false))
 389                         {
 390                                 pPanel->SetCompositeEnabled(false);
 391                         }
 392                 }
 393
 394                 return pPanel;
 395         }
 396
 397
 398 private:
 399 }; // _PanelMaker
 400
 401 _PanelRegister::_PanelRegister(void)
 402 {
 403         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 404         pUiBuilderControlTableManager->RegisterControl(L"Panel", _PanelMaker::GetInstance);
 405 }
 406 _PanelRegister::~_PanelRegister(void)
 407 {
 408         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 409         pUiBuilderControlTableManager->UnregisterControl(L"Panel");
 410 }
 411 static _PanelRegister PanelRegisterToUiBuilder;
 412 }}} //Tizen::Ui::Controls
 413