src/ui/controls/FUiCtrl_OverlayPanelImpl.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_OverlayPanelImpl.cpp
  20  * @brief               This is the implementation file for _OverlayPanelImpl class.
  21  */
  22
  23 #include <unique_ptr.h>
  24 #include <FBaseSysLog.h>
  25 #include <FUiCtrlOverlayPanel.h>
  26
  27 #include <FIo_RegistryImpl.h>
  28 #include <FGrpCoordinateSystem.h>
  29 #include <FSys_EnvironmentImpl.h>
  30 #include "FUi_CoordinateSystemUtils.h"
  31 #include "FUi_ControlManager.h"
  32 #include "FUi_ResourceSizeInfo.h"
  33 #include "FUi_UiBuilder.h"
  34 #include "FUiCtrl_FormImpl.h"
  35 #include "FUiCtrl_OverlayAgent.h"
  36 #include "FUiCtrl_OverlayPanelImpl.h"
  37
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Collection;
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::Io;
  42 using namespace Tizen::System;
  43 using namespace Tizen::Ui;
  44 using namespace Tizen::Ui::Animations;
  45 using namespace Tizen::Ui::Controls;
  46
  47 namespace Tizen { namespace Ui { namespace Controls
  48 {
  49
  50 bool _OverlayPanelImpl::__overlayPanelPixelFomatList[_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_MAX]= {false,};
  51
  52 Dimension
  53 _OverlayPanelImpl::OverlayPanelSizeInfo::GetDefaultMinimumSize(_ControlOrientation orientation) const
  54 {
  55         Dimension overlayPanelMinSize = _CoordinateSystemUtils::InverseTransform(Dimension(_OverlayAgent::GetDstRectMinWidth(), _OverlayAgent::GetDstRectMinHeight()));
  56         result r = GetLastResult();
  57         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, Dimension(-1, -1), r,"[%s] Propagating.", GetErrorMessage(r));
  58         SysTryReturn(NID_UI_CTRL, overlayPanelMinSize.width > 0 && overlayPanelMinSize.height > 0, Dimension(-1, -1), E_SYSTEM,
  59                 "[E_SYSTEM] The minimum size of overlay panel in system-info(%d, %d) is invalid.", overlayPanelMinSize.width, overlayPanelMinSize.height);
  60
  61         return overlayPanelMinSize;
  62 }
  63
  64 Dimension
  65 _OverlayPanelImpl::OverlayPanelSizeInfo::GetDefaultMaximumSize(_ControlOrientation orientation) const
  66 {
  67         Dimension overlayPanelMaxSize = CoordinateSystem::GetLogicalResolution();
  68
  69         if (orientation == _CONTROL_ORIENTATION_LANDSCAPE)
  70         {
  71                 return Dimension(overlayPanelMaxSize.height, overlayPanelMaxSize.width);
  72         }
  73
  74         return overlayPanelMaxSize;
  75 }
  76
  77 _OverlayPanelImpl*
  78 _OverlayPanelImpl::CreateOverlayPanelImplN(OverlayPanel* pPublic, const Rectangle& bounds)
  79 {
  80         result r = GET_SIZE_INFO(OverlayPanel).CheckInitialSizeValid(Dimension(bounds.width, bounds.height), _ControlManager::GetInstance()->GetOrientation());
  81         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] The size of overlay panel(%d, %d) is invalid.", bounds.width, bounds.height);
  82
  83         _OverlayPanel* pCore = _OverlayPanel::CreateOverlayPanelN();
  84         r = GetLastResult();
  85         SysTryReturn(NID_UI_CTRL, pCore != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
  86
  87         std::unique_ptr<_OverlayPanelImpl> pImpl(new (std::nothrow) _OverlayPanelImpl(pPublic, pCore));
  88         r = _ControlImpl::CheckConstruction(pCore, pImpl.get());
  89         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  90
  91         r = pImpl->InitializeBoundsProperties(GET_SIZE_INFO(OverlayPanel), bounds, _ControlManager::GetInstance()->GetOrientation());
  92         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
  93
  94         return pImpl.release();
  95 }
  96
  97 _OverlayPanelImpl*
  98 _OverlayPanelImpl::CreateOverlayPanelImplN(OverlayPanel* pPublic, const FloatRectangle& bounds)
  99 {
 100         result r = GET_SIZE_INFO(OverlayPanel).CheckInitialSizeValid(Dimension(bounds.width, bounds.height), _ControlManager::GetInstance()->GetOrientation());
 101         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_INVALID_ARG, "[E_INVALID_ARG] The size of overlay panel(%d, %d) is invalid.", bounds.width, bounds.height);
 102
 103         _OverlayPanel* pCore = _OverlayPanel::CreateOverlayPanelN();
 104         r = GetLastResult();
 105         SysTryReturn(NID_UI_CTRL, pCore != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 106
 107         std::unique_ptr<_OverlayPanelImpl> pImpl(new (std::nothrow) _OverlayPanelImpl(pPublic, pCore));
 108         r = _ControlImpl::CheckConstruction(pCore, pImpl.get());
 109         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 110
 111         r = pImpl->InitializeBoundsPropertiesF(GET_SIZE_INFO(OverlayPanel), bounds, _ControlManager::GetInstance()->GetOrientation());
 112         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 113
 114         return pImpl.release();
 115 }
 116
 117 _OverlayPanelImpl::~_OverlayPanelImpl(void)
 118 {
 119 }
 120
 121 void
 122 _OverlayPanelImpl::SetChildBuilderBounds(_ContainerImpl* pContainerImpl, _ControlOrientation controlOrientation)
 123 {
 124         FloatRectangle builderBounds;
 125         _ContainerImpl* pTempContainerImpl;
 126
 127         for(int i = 0; i < pContainerImpl->GetChildCount(); i++)
 128         {
 129                 _ControlImpl* pControlImpl =  pContainerImpl->GetChild(i);
 130                 bool exist = pControlImpl->GetBuilderBoundsF(controlOrientation, builderBounds);
 131                 if (!exist)
 132                 {
 133                         continue;
 134                 }
 135
 136                 pControlImpl->SetBounds(builderBounds);
 137                 pTempContainerImpl = dynamic_cast<_ContainerImpl*>(pControlImpl);
 138                 if (pTempContainerImpl != null)
 139                 {
 140                         SetChildBuilderBounds(pTempContainerImpl, controlOrientation);
 141                 }
 142         }
 143 }
 144
 145 result
 146 _OverlayPanelImpl::OnAttachedToMainTree(void)
 147 {
 148         //result r = SetFocusable(false);
 149         result r = E_SUCCESS;
 150
 151         _ControlOrientation controlOrientation = _CONTROL_ORIENTATION_PORTRAIT;
 152         FloatRectangle builderBounds;
 153         bool exist = GetBuilderBoundsF(controlOrientation, builderBounds);
 154
 155         if (exist)
 156         {
 157                 _ContainerImpl* pContainerImpl = this;
 158                 _FormImpl* pParentImpl = null;
 159
 160                 while (pContainerImpl)
 161                 {
 162                         pParentImpl = dynamic_cast<_FormImpl*>(pContainerImpl->GetParent());
 163                         if (pParentImpl != null)
 164                         {
 165                                 break;
 166                         }
 167                         else
 168                         {
 169                                 pContainerImpl = pContainerImpl->GetParent();
 170                         }
 171                 }
 172
 173                 if (pParentImpl)
 174                 {
 175                         OrientationStatus orientation = pParentImpl->GetOrientationStatus();
 176                         if (orientation == ORIENTATION_STATUS_LANDSCAPE || orientation == ORIENTATION_STATUS_LANDSCAPE_REVERSE)
 177                         {
 178                                 controlOrientation = _CONTROL_ORIENTATION_LANDSCAPE;
 179                                 GetBuilderBoundsF(controlOrientation, builderBounds);
 180                         }
 181
 182                         r = SetBounds(builderBounds);
 183                         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Failed to SetBounds", GetErrorMessage(r));
 184                         SetChildBuilderBounds(this, controlOrientation);
 185                 }
 186         }
 187
 188         r = _ContainerImpl::OnAttachedToMainTree();
 189         SysTryLog(NID_UI_CTRL, r == E_SUCCESS, "[%s] Failed to OnAttachedToMainTree", GetErrorMessage(r));
 190
 191         return r;
 192 }
 193
 194 void
 195 _OverlayPanelImpl::SetRendererRotation(OverlayPanel::Rotation rotation)
 196 {
 197         GetCore().SetRendererRotation(rotation);
 198 }
 199
 200 void
 201 _OverlayPanelImpl::SetRendererAspectRatio(bool fix)
 202 {
 203         GetCore().SetRendererAspectRatio(fix);
 204 }
 205
 206 result
 207 _OverlayPanelImpl::SetRenderSize(const Dimension& dimension)
 208 {
 209         FloatDimension floatDimension = _CoordinateSystemUtils::ConvertToFloat(dimension);
 210         return GetCore().SetRenderSize(floatDimension);
 211 }
 212
 213 result
 214 _OverlayPanelImpl::SetRenderSize(const FloatDimension& dimension)
 215 {
 216         return GetCore().SetRenderSize(dimension);
 217 }
 218
 219 result
 220 _OverlayPanelImpl::SetInputBuffer(const Dimension& destDim, const ByteBuffer& srcBuffer, const Dimension& srcDim, OverlayPanel::BufferPixelFormat srcFormat)
 221 {
 222         FloatDimension destFloatDim = _CoordinateSystemUtils::ConvertToFloat(destDim);
 223         return SetInputBuffer(destFloatDim, srcBuffer, srcDim, srcFormat);
 224 }
 225
 226 result
 227 _OverlayPanelImpl::SetInputBuffer(const FloatDimension& destDim, const ByteBuffer& srcBuffer, const Dimension& srcDim, OverlayPanel::BufferPixelFormat srcFormat)
 228 {
 229         if (!__overlayPanelPixelFomatList[0])
 230         {
 231                 result r = _OverlayPanelImpl::SetPixelFormatList();
 232                 SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 233         }
 234
 235         if (!__overlayPanelPixelFomatList[srcFormat])
 236         {
 237                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] The Source format[%d] is unsupported.", srcFormat);
 238                 return E_UNSUPPORTED_FORMAT;
 239         }
 240
 241         result r = GetCore().SetInputBuffer(destDim, srcBuffer, srcDim, srcFormat);
 242
 243         if (r == E_INVALID_ARG || r == E_UNSUPPORTED_FORMAT || r == E_SYSTEM)
 244         {
 245                 SysLogException(NID_UI_CTRL, r, "[%s] Propagating.", GetErrorMessage(r));
 246         }
 247         else if (r != E_SUCCESS)
 248         {
 249                 r = E_SYSTEM;
 250                 SysLogException(NID_UI_CTRL, r, "[E_SYSTEM] A system error occurred.");
 251         }
 252
 253         return r;
 254 }
 255
 256 result
 257 _OverlayPanelImpl::GetBackgroundBufferInfo(BufferInfo& bufferInfo) const
 258 {
 259         result r = GetCore().GetBackgroundBufferInfo(bufferInfo);
 260
 261         if (r == E_OPERATION_FAILED)
 262         {
 263                 SysLogException(NID_UI_CTRL, r, "[%s] Propagating.", GetErrorMessage(r));
 264         }
 265         else if (r != E_SUCCESS)
 266         {
 267                 r = E_OPERATION_FAILED;
 268                 SysLogException(NID_UI_CTRL, r, "[E_OPERATION_FAILED] failed to GetBackgroundBufferInfo.");
 269         }
 270
 271         return r;
 272 }
 273
 274 Color
 275 _OverlayPanelImpl::GetMaskingColor(void) const
 276 {
 277         return GetCore().GetMaskingColor();
 278 }
 279
 280 void
 281 _OverlayPanelImpl::OnChangeLayout(_ControlOrientation orientation)
 282 {
 283         result r = InitializeBoundsProperties(GET_SIZE_INFO(OverlayPanel), orientation);
 284         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 285
 286         _ControlImpl::OnChangeLayout(orientation);
 287 }
 288
 289 _OverlayPanelImpl::_OverlayPanelImpl(OverlayPanel* pPublic, _OverlayPanel* pCore)
 290         : _ContainerImpl(pPublic, pCore)
 291 {
 292 }
 293
 294 const char*
 295 _OverlayPanelImpl::GetPublicClassName(void) const
 296 {
 297         return "Tizen::Ui::Controls::OverlayPanel";
 298 }
 299
 300 const _OverlayPanel&
 301 _OverlayPanelImpl::GetCore(void) const
 302 {
 303         return static_cast <const _OverlayPanel&>(_ControlImpl::GetCore());
 304 }
 305
 306 _OverlayPanel&
 307 _OverlayPanelImpl::GetCore(void)
 308 {
 309         return static_cast <_OverlayPanel&>(_ControlImpl::GetCore());
 310 }
 311
 312 const OverlayPanel&
 313 _OverlayPanelImpl::GetPublic(void) const
 314 {
 315         return static_cast <const OverlayPanel&>(_ControlImpl::GetPublic());
 316 }
 317
 318 OverlayPanel&
 319 _OverlayPanelImpl::GetPublic(void)
 320 {
 321         return static_cast <OverlayPanel&>(_ControlImpl::GetPublic());
 322 }
 323
 324 _OverlayPanelImpl*
 325 _OverlayPanelImpl::GetInstance(OverlayPanel& overlayPanel)
 326 {
 327         return static_cast<_OverlayPanelImpl*>(_ControlImpl::GetInstance(overlayPanel));
 328 }
 329
 330 const _OverlayPanelImpl*
 331 _OverlayPanelImpl::GetInstance(const OverlayPanel& overlayPanel)
 332 {
 333         return static_cast<const _OverlayPanelImpl*>(_ControlImpl::GetInstance(overlayPanel));
 334 }
 335
 336 result
 337 _OverlayPanelImpl::SetPixelFormatList(void)
 338 {
 339         if (__overlayPanelPixelFomatList[0])
 340         {
 341                 return E_SUCCESS;
 342         }
 343
 344         std::unique_ptr< IListT<bool> > pFormatList(_OverlayAgent::GetPixelFormatListN());
 345         SysTryReturn(NID_UI_CTRL, pFormatList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] failed to create a list instance");
 346
 347         bool set = false;
 348         for (int formatIndex = 0; formatIndex < pFormatList->GetCount(); formatIndex++)
 349         {
 350                 bool value = false;
 351                 pFormatList->GetAt(formatIndex, value);
 352
 353                 if (value)
 354                 {
 355                         __overlayPanelPixelFomatList[formatIndex + 1] = true;
 356                         set = true;
 357                 }
 358         }
 359
 360         SysAssertf(set, "The list of supported pixel formats is an invalid.");
 361
 362         __overlayPanelPixelFomatList[0] = set;
 363
 364         return E_SUCCESS;
 365 }
 366
 367 IListT<OverlayPanel::BufferPixelFormat>*
 368 _OverlayPanelImpl::GetSupportedBufferPixelFormatListN(void)
 369 {
 370         result r = E_SUCCESS;
 371
 372         if (!__overlayPanelPixelFomatList[0])
 373         {
 374                 r = _OverlayPanelImpl::SetPixelFormatList();
 375                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 376         }
 377
 378         std::unique_ptr< ArrayListT<OverlayPanel::BufferPixelFormat> > pFormatList( new (std::nothrow) ArrayListT<OverlayPanel::BufferPixelFormat>());
 379         SysTryReturn(NID_UI_CTRL, pFormatList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] failed to create a list instance");
 380
 381         r = pFormatList->Construct();
 382         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 383
 384         for (int index = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888; index <= _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY; index++)
 385         {
 386                 if (__overlayPanelPixelFomatList[index])
 387                 {
 388                         r = pFormatList->Add(static_cast<OverlayPanel::BufferPixelFormat>(index - 1));
 389                 }
 390         }
 391         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 392
 393         return pFormatList.release();
 394 }
 395
 396 result
 397 _OverlayPanelImpl::EvaluateBounds(OverlayPanelEvaluationOption option, FloatRectangle& rect, bool& modified)
 398 {
 399         switch (option)
 400         {
 401         case OVERLAY_PANEL_EVAL_OPT_GREATER_THAN:
 402                 return _OverlayAgent::EvaluateBounds(OVERLAY_AGENT_EVALUATION_OPTION_GREATER_THAN, rect, modified);
 403
 404         case OVERLAY_PANEL_EVAL_OPT_LESS_THAN:
 405                 return _OverlayAgent::EvaluateBounds(OVERLAY_AGENT_EVALUATION_OPTION_LESS_THAN, rect, modified);
 406
 407         default:
 408                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument is used. The OverlayPanelEvaluationOption is invalid.");
 409                 return E_INVALID_ARG;
 410         }
 411 }
 412
 413 int
 414 _OverlayPanelImpl::GetWidthUnit(void)
 415 {
 416         int widthUnit = _OverlayAgent::GetWidthUnit();
 417         SysAssertf(widthUnit > 0, "Failed to get a OverlayAgent's WidthUnit");
 418
 419         return widthUnit;
 420 }
 421
 422 int
 423 _OverlayPanelImpl::GetHeightUnit(void)
 424 {
 425         int heightUnit = _OverlayAgent::GetHeightUnit();
 426         SysAssertf(heightUnit > 0, "Failed to get a OverlayAgent's HeightUnit");
 427
 428         return heightUnit;
 429 }
 430
 431 int
 432 _OverlayPanelImpl::GetMaxCount(void)
 433 {
 434         int maxCount = _OverlayAgent::GetMaxCount();
 435         SysAssertf(maxCount > 0, "Failed to get a OverlayAgent's MaxCount");
 436
 437         return maxCount;
 438 }
 439
 440 class _OverlayPanelMaker
 441         : public _UiBuilderControlMaker
 442 {
 443 public:
 444         _OverlayPanelMaker(_UiBuilder* uibuilder)
 445                 :_UiBuilderControlMaker(uibuilder)
 446         {
 447         };
 448
 449         virtual ~_OverlayPanelMaker()
 450         {
 451         };
 452
 453         static _UiBuilderControlMaker* GetInstance(_UiBuilder* uibuilder)
 454         {
 455                 _OverlayPanelMaker* pOverlayPanelMaker = new (std::nothrow) _OverlayPanelMaker(uibuilder);
 456                 SysTryReturn(NID_UI_CTRL, pOverlayPanelMaker != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 457
 458                 return pOverlayPanelMaker;
 459         };
 460
 461 protected:
 462         virtual Tizen::Ui::Control* Make(_UiBuilderControl* pControl)
 463         {
 464                 _UiBuilderControlLayout* pControlProperty = null;
 465
 466                 GetProperty(pControl, &pControlProperty);
 467                 SysTryReturn(NID_UI_CTRL, pControlProperty != null, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 468
 469                 std::unique_ptr<OverlayPanel> pOverlayPanel(new (std::nothrow) OverlayPanel());
 470                 SysTryReturn(NID_UI_CTRL, pOverlayPanel != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 471
 472                 FloatRectangle overlayPanelBounds = pControlProperty->GetRectF();
 473                 bool modified = false;
 474
 475                 OverlayPanel::EvaluateBounds(OVERLAY_PANEL_EVAL_OPT_LESS_THAN, overlayPanelBounds, modified);
 476                 SysTryLog(NID_UI_CTRL, modified, "The bounds of OverlayPanel is modified into [%.3f, %.3f, %.3f, %.3f]"
 477                         , overlayPanelBounds.x, overlayPanelBounds.y, overlayPanelBounds.width, overlayPanelBounds.height);
 478
 479                 result r = pOverlayPanel->Construct(overlayPanelBounds);
 480                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 481
 482                 return pOverlayPanel.release();
 483         }
 484 };
 485
 486 _OverlayPanelRegister::_OverlayPanelRegister()
 487 {
 488         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 489         pUiBuilderControlTableManager->RegisterControl("OverlayPanel", _OverlayPanelMaker::GetInstance);
 490 }
 491
 492 _OverlayPanelRegister::~_OverlayPanelRegister()
 493 {
 494         _UiBuilderControlTableManager* pUiBuilderControlTableManager = _UiBuilderControlTableManager::GetInstance();
 495         pUiBuilderControlTableManager->UnregisterControl("OverlayPanel");
 496 }
 497 static _OverlayPanelRegister OverlayPanelRegisterToUIbuilder;
 498 }}} // Tizen::Ui::Controls