src/ui/controls/FUiCtrl_OverlayRegionImpl.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_OverlayRegionImpl.cpp
  20  * @brief               This is the implementation file for _OverlayRegionImpl class.
  21  *
  22  */
  23
  24 #include <new>
  25
  26 #include <libxml/parser.h>
  27 #include <libxml/tree.h>
  28
  29 #include <Elementary.h>
  30
  31 #include <FSysSystemInfo.h>
  32 #include <FIoFile.h>
  33 #include <FBaseInteger.h>
  34 #include <FBaseSysLog.h>
  35
  36 #include <FGrp_BufferInfoImpl.h>
  37 #include <FSys_EnvironmentImpl.h>
  38 #include <FIo_RegistryImpl.h>
  39
  40 #include "FUi_CoordinateSystemUtils.h"
  41 #include "FUiCtrl_FormImpl.h"
  42 #include "FUiCtrl_OverlayRegionImpl.h"
  43 #include "FUiCtrl_OverlayAgent.h"
  44
  45 using namespace Tizen::Base;
  46 using namespace Tizen::Ui;
  47 using namespace Tizen::Ui::Controls;
  48 using namespace Tizen::Media;
  49 using namespace Tizen::Graphics;
  50 using namespace Tizen::Io;
  51 using namespace Tizen::System;
  52
  53 namespace
  54 {
  55         const int _ROTATION_COUNT = 4;
  56
  57         const wchar_t* _UI_REGISTRY_PATH = L"/usr/etc/system-info.ini";
  58         const wchar_t* _UI_INFO_SESSION = L"UiControlInfo";
  59
  60         const char* _MEDIA_CAPABILITY_FILE_PATH = "/usr/etc/media-capability.xml";
  61         const char* _CAM_PRIMARY_DIRECTION = "Camera.Primary.Direction";
  62         const char* _CAM_PRIMARY_ROTATION = "Camera.Primary.Rotation";
  63         const char* _CAM_SECONDARY_DIRECTION = "Camera.Secondary.Direction";
  64         const char* _CAM_SECONDARY_ROTATION = "Camera.Secondary.Rotation";
  65
  66         class _OverlayRegionMediaCapability
  67         {
  68         public:
  69                 _OverlayRegionMediaCapability(void);
  70
  71                 virtual ~_OverlayRegionMediaCapability(void);
  72
  73                 result Construct(void);
  74                 result ParseCapability(const char* xmlBuffer, int length);
  75                 void ParseSection(xmlNodePtr pRoot, const Tizen::Base::String& section);
  76
  77                 int cameraPrimaryDirection;
  78                 int cameraPrimaryRotation;
  79                 int cameraSecondaryDirection;
  80                 int cameraSecondaryRotation;
  81         }; //_OverlayRegionMediaCapability
  82 }
  83
  84 namespace Tizen { namespace Ui { namespace Controls
  85 {
  86
  87 int _OverlayRegionImpl::overlayRegionWidthUnit = -1;
  88 int _OverlayRegionImpl::overlayRegionHeightUnit = -1;
  89 int _OverlayRegionImpl::overlayRegionMaxCount = -1;
  90 bool _OverlayRegionImpl::overlayRegionPixelFomatList[]= {false,};
  91
  92 result
  93 _IsValidSrcDim(const Tizen::Graphics::Dimension& srcDim, int multipleValueW, int multipleValueH)
  94 {
  95         result r = E_SUCCESS;
  96
  97         if (srcDim.width < 0 || srcDim.height < 0)
  98         {
  99                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] Source dimension has negative value [w : %4d, h : %4d].",
 100                                  srcDim.width, srcDim.height);
 101                 r = E_INVALID_ARG;
 102         }
 103
 104         if (srcDim.width % multipleValueW || srcDim.height % multipleValueH)
 105         {
 106                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] srcDim[%4d, %4d] should be multiple of [%4d, %4d].",
 107                                  srcDim.width, srcDim.height, multipleValueW, multipleValueH);
 108                 r = E_INVALID_ARG;
 109         }
 110
 111         SysLog(NID_UI_CTRL, "srcDim w:%d h:%d, UnitW[%d], UnitH[%d]", srcDim.width, srcDim.height, multipleValueW, multipleValueH);
 112
 113         return r;
 114 }
 115
 116 OverlayRegionRotate
 117 _ConvertCamToOverlayRegionRotation(OverlayRegionType type, int camDir, int camRot, int formOrientation)
 118 {
 119         OverlayRegionRotate rotation = OVERLAYREGION_ROTATE_NONE;
 120
 121         int tempCamDir = 0;
 122         int tempCamRot = 0;
 123         int tempFormRot = 0;
 124
 125         switch (camDir)
 126         {
 127         case 1://CAMERA_DIRECTION_FRONT:
 128                 tempCamDir = 1;
 129                 break;
 130         case 2://CAMERA_DIRECTION_BACK:
 131                 tempCamDir = 2;
 132                 break;
 133         default:
 134                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] cameraRot [%d] is invalid", camRot);
 135                 return rotation;
 136         }
 137
 138         switch (camRot)
 139         {
 140         case 1://CAMERA_ROTATION_NONE:
 141                 tempCamRot = 0;
 142                 break;
 143         case 2://CAMERA_ROTATION_90:
 144                 tempCamRot = 1;
 145                 break;
 146         case 3://CAMERA_ROTATION_180:
 147                 tempCamRot = 2;
 148                 break;
 149         case 4://CAMERA_ROTATION_270:
 150                 tempCamRot = 3;
 151                 break;
 152         default:
 153                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] cameraRot [%d] is invalid", camRot);
 154                 return rotation;
 155         }
 156
 157         switch (static_cast<OrientationStatus>(formOrientation))
 158         {
 159         case ORIENTATION_STATUS_PORTRAIT:
 160                 tempFormRot = 0;
 161                 break;
 162         case ORIENTATION_STATUS_LANDSCAPE:
 163                 tempFormRot = 1;
 164                 break;
 165         case ORIENTATION_STATUS_PORTRAIT_REVERSE:
 166                 tempFormRot = 2;
 167                 break;
 168         case ORIENTATION_STATUS_LANDSCAPE_REVERSE:
 169                 tempFormRot = 3;
 170                 break;
 171         default:
 172                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] formOrientation [%d] is invalid", formOrientation);
 173                 return rotation;
 174         }
 175
 176         if (type == OVERLAY_REGION_TYPE_NORMAL)
 177         {
 178                 rotation = OVERLAYREGION_ROTATE_0;
 179         }
 180         else if(type == OVERLAY_REGION_TYPE_PRIMARY_CAMERA)
 181         {
 182                 rotation = static_cast<OverlayRegionRotate>((_ROTATION_COUNT - (tempFormRot - tempCamRot)) % _ROTATION_COUNT);
 183         }
 184         else if(type == OVERLAY_REGION_TYPE_SECONDARY_CAMERA)
 185         {
 186                 rotation = static_cast<OverlayRegionRotate>((tempFormRot + tempCamRot) % _ROTATION_COUNT);
 187         }
 188
 189         SysLog(NID_UI_CTRL, "type : %d, rotation:%d, cameraDir : %d, camRot:%d, formOrientation:%d", type, rotation, tempCamDir, tempCamRot, tempFormRot);
 190
 191         return rotation;
 192 }
 193
 194 _OverlayRegionImpl::_OverlayRegionImpl(void)
 195         : __pParentForm(null)
 196         , __pOverlayRegion(null)
 197         , __destRect(0, 0, 0, 0)
 198         , __overlayRegionType(OVERLAY_REGION_TYPE_MIN)
 199         , __showState(true)
 200         , __myIdx(-1)
 201         , __cameraDirection(2/*CAMERA_DIRECTION_BACK*/)
 202         , __cameraRotation(1/*CAMERA_ROTATION_NONE*/)
 203         , __pOverlayAgent(null)
 204 {
 205
 206 }
 207
 208 _OverlayRegionImpl::~_OverlayRegionImpl(void)
 209 {
 210         if (__pParentForm)
 211         {
 212                 if (__myIdx != -1)
 213                 {
 214                         __pParentForm->__ppOverlayerRegionImplArray[__myIdx] = null;
 215                 }
 216
 217                 __pParentForm->__overlayRegionCount--;
 218         }
 219
 220         SysLog(NID_UI_CTRL, "destructor : __myIdx [%d], parentForm : [%x]", __myIdx, __pParentForm);
 221
 222         if (__pOverlayAgent)
 223         {
 224                 delete __pOverlayAgent;
 225         }
 226 }
 227
 228 Tizen::Graphics::Rectangle
 229 _OverlayRegionImpl::GetBounds(void) const
 230 {
 231         return __destRect;
 232 }
 233
 234 void
 235 _OverlayRegionImpl::GetBounds(int& x, int& y, int& width, int& height) const
 236 {
 237         x = __destRect.x;
 238         y = __destRect.y;
 239         width = __destRect.width;
 240         height = __destRect.height;
 241 }
 242
 243 int test = 1;
 244
 245 result
 246 _OverlayRegionImpl::SetInputBuffer(const Tizen::Base::ByteBuffer& srcBuffer, const Tizen::Graphics::Dimension& srcDim, OverlayRegionBufferPixelFormat srcFormat, bool isUserInput)
 247 {
 248         result r = _IsValidSrcDim(srcDim, OverlayRegion::GetWidthUnit(), OverlayRegion::GetHeightUnit());
 249         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 250
 251          if (!_OverlayRegionImpl::overlayRegionPixelFomatList[0])
 252         {
 253                 result r = _OverlayRegionImpl::SetPixelFormatList();
 254                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 255         }
 256
 257         _OverlayAgentBufferPixelFormat  format = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888;
 258
 259         switch (srcFormat)
 260         {
 261         case OVERLAY_REGION_BUFFER_PIXEL_FORMAT_ARGB8888:
 262                 format = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888;
 263                 break;
 264         case OVERLAY_REGION_BUFFER_PIXEL_FORMAT_RGB565:
 265                 format = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_RGB565;
 266                 break;
 267         case OVERLAY_REGION_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR:
 268                 format = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR;
 269                 break;
 270         case OVERLAY_REGION_BUFFER_PIXEL_FORMAT_NV12:
 271                 format = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_NV12;
 272                 break;
 273         case OVERLAY_REGION_BUFFER_PIXEL_FORMAT_UYVY:
 274                 format = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY;
 275                 break;
 276         default:
 277                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] srcFormat [%d] is not supported!", srcFormat);
 278                 return E_UNSUPPORTED_FORMAT;
 279         }
 280
 281         if (!_OverlayRegionImpl::overlayRegionPixelFomatList[srcFormat])
 282         {
 283                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] srcFormat [%d] is not supported!", srcFormat);
 284                 return E_UNSUPPORTED_FORMAT;
 285         }
 286
 287         int size = srcBuffer.GetCapacity();
 288         SysTryReturnResult(NID_UI_CTRL, size > 0, E_INVALID_ARG, "[E_INVALID_ARG] source size[%d] is invalid!", size);
 289
 290         r = __pOverlayAgent->SetInputBuffer(Dimension(__destRect.width, __destRect.height), srcBuffer, srcDim, format);
 291         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 292
 293         SysTryReturnResult(NID_UI_CTRL, __showState, E_SYSTEM, "[E_SYSTEM]__showState is false! don't draw now..");
 294
 295         r = __pOverlayAgent->Draw();
 296         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 297
 298         return E_SUCCESS;
 299 }
 300
 301 result
 302 _OverlayRegionImpl::GetBackgroundBufferInfo(Tizen::Graphics::BufferInfo& info) const
 303 {
 304         BufferInfo bgBufInfo;
 305         _BufferInfoImpl* pBufInfoImpl = null;
 306
 307         SysTryReturnResult(NID_UI_CTRL, __pOverlayAgent != null, E_INVALID_STATE, "[E_INVALID_STATE] __pOverlayAgent is null.");
 308         __pOverlayAgent->GetBufferInfo(info);
 309
 310         pBufInfoImpl = _BufferInfoImpl::GetInstance(info);
 311         SysTryReturnResult(NID_UI_CTRL, pBufInfoImpl != null , E_SYSTEM, "[E_SYSTEM] pBufInfoImpl is null.");
 312
 313         Tizen::Ui::Controls::_FormImpl* pFormImpl = static_cast<_FormImpl*>(__pParentForm->GetUserData());
 314         SysTryReturn(NID_UI_CTRL, pFormImpl != null, false, E_SYSTEM, "[E_SYSTEM] pParentForm impl is null.");
 315
 316         Tizen::Ui::OrientationStatus formOrientationStatus = pFormImpl->GetOrientationStatus();
 317         switch (formOrientationStatus)
 318         {
 319         case ORIENTATION_STATUS_NONE:
 320                 // fall through
 321         case ORIENTATION_STATUS_PORTRAIT:
 322                 pBufInfoImpl->SetOrientation(_BufferInfoImpl::ORIENTATION_PORTRAIT);
 323                 break;
 324         case ORIENTATION_STATUS_LANDSCAPE :
 325                 pBufInfoImpl->SetOrientation(_BufferInfoImpl::ORIENTATION_LANDSCAPE);
 326                 break;
 327         case ORIENTATION_STATUS_PORTRAIT_REVERSE:
 328                 pBufInfoImpl->SetOrientation(_BufferInfoImpl::ORIENTATION_PORTRAIT_REVERSE);
 329                 break;
 330         case ORIENTATION_STATUS_LANDSCAPE_REVERSE:
 331                 pBufInfoImpl->SetOrientation(_BufferInfoImpl::ORIENTATION_LANDSCAPE_REVERSE);
 332                 break;
 333         }
 334
 335         switch (__cameraRotation)
 336         {
 337         case 1://CAMERA_ROTATION_NONE
 338                 pBufInfoImpl->SetRotation(_BufferInfoImpl::ROTATION_0);
 339                 break;
 340         case 2://CAMERA_ROTATION_90:
 341                 pBufInfoImpl->SetRotation(_BufferInfoImpl::ROTATION_90);
 342                 break;
 343         case 3://CAMERA_ROTATION_180:
 344                 pBufInfoImpl->SetRotation(_BufferInfoImpl::ROTATION_180);
 345                 break;
 346         case 4://CAMERA_ROTATION_270:
 347                 pBufInfoImpl->SetRotation(_BufferInfoImpl::ROTATION_270);
 348                 break;
 349         }
 350
 351         return E_SUCCESS;
 352 }
 353
 354 result
 355 _OverlayRegionImpl::Show(void) const
 356 {
 357         SysTryReturnResult(NID_UI_CTRL, __pOverlayAgent != null, E_SYSTEM, "[E_SYSTEM] __pOverlayAgent is null.");
 358         return __pOverlayAgent->Show();
 359 }
 360
 361 result
 362 _OverlayRegionImpl::Construct(_Form* pParentForm, OverlayRegionType overlayRegionType, const Point& leftTopPos, const Rectangle& userDestRect, const Rectangle& finalPhyRect)
 363 {
 364         result r = E_SUCCESS;
 365         byte* pBuf = null;
 366
 367         switch (overlayRegionType)
 368         {
 369         case OVERLAY_REGION_TYPE_PRIMARY_CAMERA:
 370         {
 371                 _OverlayRegionMediaCapability capability;
 372                 r = capability.Construct();
 373                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 374
 375                 __cameraDirection = capability.cameraPrimaryDirection;
 376                 __cameraRotation = capability.cameraPrimaryRotation;
 377
 378                 break;
 379         }
 380         case OVERLAY_REGION_TYPE_SECONDARY_CAMERA:
 381         {
 382                 _OverlayRegionMediaCapability capability;
 383                 r = capability.Construct();
 384                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 385
 386                 __cameraDirection = capability.cameraSecondaryDirection;
 387                 __cameraRotation = capability.cameraSecondaryRotation;
 388
 389                 break;
 390         }
 391         case OVERLAY_REGION_TYPE_NORMAL:
 392                 break;
 393         default:
 394                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "[E_UNSUPPORTED_FORMAT] overlayRegionType [%d] is not supported!", overlayRegionType);
 395                 return E_UNSUPPORTED_FORMAT;
 396         }
 397
 398         SysTryReturnResult(NID_UI_CTRL, pParentForm != null, E_SYSTEM, "[E_SYSTEM] pParentForm impl is null.");
 399
 400         Tizen::Ui::Controls::_FormImpl* pFormImpl = static_cast<_FormImpl*>(pParentForm->GetUserData());
 401         SysTryReturnResult(NID_UI_CTRL, pFormImpl != null, E_SYSTEM, "[E_SYSTEM] pFormImpl impl is null.");
 402
 403         OverlayRegionRotate rotation = _ConvertCamToOverlayRegionRotation(overlayRegionType, __cameraDirection, __cameraRotation, pFormImpl->GetOrientationStatus());
 404         SysTryReturnResult(NID_UI_CTRL, rotation != OVERLAYREGION_ROTATE_NONE, E_SYSTEM, "[E_SYSTEM] __rotation is OVERLAYREGION_ROTATE_NONE.");
 405
 406         //Rectangle overlayRect(leftTopPos.x, leftTopPos.y, destRect.width, destRect.height);
 407         //SysLog(NID_UI_CTRL,"overlayAgentRect[%d, %d, %d, %d]", overlayRect.x, overlayRect.y, overlayRect.width, overlayRect.height);
 408
 409         _OverlayAgentStyle overlayAgentType = _OVERLAY_AGENT_STYLE_REGION_SW;
 410         String preferredEngineConfig(elm_config_preferred_engine_get());
 411         if(preferredEngineConfig.Equals("opengl_x11", true))
 412         {
 413                 overlayAgentType = _OVERLAY_AGENT_STYLE_REGION_GL;
 414                 SysLog(NID_UI_CTRL,"xml : HwAcceleration was set to On");
 415         }
 416         else if(preferredEngineConfig.Equals("software_x11", true))
 417         {
 418                 overlayAgentType = _OVERLAY_AGENT_STYLE_REGION_SW;
 419                 SysLog(NID_UI_CTRL,"xml : HwAcceleration was set to Off");
 420         }
 421         else
 422         {
 423                 String engineConfig(elm_config_engine_get());
 424                 if(engineConfig.Equals("opengl_x11", true))
 425                 {
 426                         overlayAgentType = _OVERLAY_AGENT_STYLE_REGION_GL;
 427                         SysLog(NID_UI_CTRL,"dev setting option : gl backend");
 428                 }
 429                 else
 430                 {
 431                         SysLog(NID_UI_CTRL,"dev setting option : sw backend");
 432                 }
 433         }
 434
 435         __pOverlayAgent = _OverlayAgent::CreateInstanceN(overlayAgentType, *pParentForm, finalPhyRect);
 436         r = GetLastResult();
 437         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS && __pOverlayAgent != null, r, r, "[%s] pPropagating.", GetErrorMessage(r));
 438
 439         __pParentForm = pParentForm;
 440         __overlayRegionType = overlayRegionType;
 441         __destRect = userDestRect;
 442
 443         if(overlayAgentType == _OVERLAY_AGENT_STYLE_REGION_GL)
 444         {
 445                 r = __pOverlayAgent->CreatePixmap();
 446                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 447         }
 448         else
 449         {
 450                 SysLog(NID_UI_CTRL,"not need to make a pixmap");
 451         }
 452
 453         switch(rotation)
 454         {
 455         case OVERLAYREGION_ROTATE_0:
 456                 __pOverlayAgent->SetRotation(_OVERLAY_AGENT_ROTATION_NONE);
 457                 break;
 458         case OVERLAYREGION_ROTATE_90:
 459                 __pOverlayAgent->SetRotation(_OVERLAY_AGENT_ROTATION_90);
 460                 break;
 461         case OVERLAYREGION_ROTATE_180:
 462                 __pOverlayAgent->SetRotation(_OVERLAY_AGENT_ROTATION_180);
 463                 break;
 464         case OVERLAYREGION_ROTATE_270:
 465                 __pOverlayAgent->SetRotation(_OVERLAY_AGENT_ROTATION_270);
 466                 break;
 467         default:
 468                 SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] rotate value[%d] is invalid.", rotation);
 469                 return E_SYSTEM;
 470         }
 471
 472         if (overlayAgentType == _OVERLAY_AGENT_STYLE_REGION_SW)
 473         {
 474                 int i, j;
 475                 int size = finalPhyRect.width * finalPhyRect.height * 4;
 476                 pBuf = new (std::nothrow) byte[size];
 477                 SysTryCatch(NID_UI_CTRL, pBuf != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pBuf is null.");
 478
 479                 unsigned long* pPos = (unsigned long*)pBuf;
 480                 for(i=0;i<finalPhyRect.height;i++)
 481                 {
 482                         for(j=0;j<finalPhyRect.width;j++)
 483                         {
 484                                 *pPos = 0xFF000000;
 485                                 pPos++;
 486                         }
 487                 }
 488
 489                 ByteBuffer buffer;
 490                 r = buffer.Construct(size);
 491                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 492
 493                 buffer.SetArray(pBuf, 0, size);
 494                 r = SetInputBuffer(buffer, Dimension(finalPhyRect.width, finalPhyRect.height), OVERLAY_REGION_BUFFER_PIXEL_FORMAT_ARGB8888, true);
 495                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 496
 497                 delete[] pBuf;
 498
 499                 SysLog(NID_UI_CTRL,"initializes the origin image object buf");
 500         }
 501
 502         return r;
 503
 504 CATCH:
 505         delete[] pBuf;
 506         delete __pOverlayAgent;
 507         __pOverlayAgent = null;
 508         return GetLastResult();
 509 }
 510
 511 OverlayRegion*
 512 _OverlayRegionImpl::CreateOverlayRegionN(void)
 513 {
 514         OverlayRegion* pOverlayRegion = null;
 515         pOverlayRegion = new (std::nothrow) OverlayRegion();
 516         SysTryReturn(NID_UI_CTRL, pOverlayRegion != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pOverlayRegion is null.");
 517
 518         __pOverlayRegion = pOverlayRegion;
 519         __pOverlayRegion->__pOverlayRegionImpl = this;
 520
 521         return pOverlayRegion;
 522 }
 523
 524 void
 525 _OverlayRegionImpl::SetFormArrayIndex(int index)
 526 {
 527         __myIdx = index;
 528         return;
 529 }
 530
 531 OverlayRegion*
 532 _OverlayRegionImpl::GetOverlayRegion(void) const
 533 {
 534         return __pOverlayRegion;
 535 }
 536
 537 void
 538 _OverlayRegionImpl::GoForeground(void)
 539 {
 540         __showState = true;
 541
 542         SysTryReturnVoidResult(NID_UI_CTRL, __pOverlayAgent != null, E_SYSTEM, "[E_SYSTEM] __pOverlayAgent impl is null.");
 543         SysLog(NID_UI_CTRL, "GoForeground  pixmap : %d", __pOverlayAgent->GetPixmap());
 544         //__pOverlayAgent->AdjustImageObject();
 545
 546         return;
 547 }
 548
 549 void
 550 _OverlayRegionImpl::GoBackground(void)
 551 {
 552         __showState = false;
 553
 554         SysTryReturnVoidResult(NID_UI_CTRL, __pOverlayAgent != null, E_SYSTEM, "[E_SYSTEM] __pOverlayAgent impl is null.");
 555         __pOverlayAgent->UngrabXvPort();
 556
 557         SysLog(NID_UI_CTRL, "GoBackground  pixmap : %d", __pOverlayAgent->GetPixmap());
 558
 559         return;
 560 }
 561
 562 result
 563 _OverlayRegionImpl::IsValidOverlayRect(Tizen::Graphics::Rectangle& userRect, Tizen::Graphics::Rectangle& overlayPhysicalRect, const Tizen::Graphics::Rectangle& basePhysicalRect, bool& modified)
 564 {
 565         result r = E_SUCCESS;
 566
 567         if ((overlayPhysicalRect.width < _OverlayAgent::GetDstRectMinWidth()) || (overlayPhysicalRect.height < _OverlayAgent::GetDstRectMinHeight()))
 568         {
 569                         SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] size of OverlayRegoin is invalid [w : %4d, h : %4d].",
 570                                          overlayPhysicalRect.width, overlayPhysicalRect.height);
 571                         return E_INVALID_ARG;
 572         }
 573
 574         int base = overlayRegionWidthUnit / 2;
 575         if (base != 0)
 576         {
 577                 int modW = overlayPhysicalRect.width % overlayRegionWidthUnit;
 578                 if (modW != 0)
 579                 {
 580                         if (modW <= base)
 581                         {
 582                                 overlayPhysicalRect.width -= modW;
 583                         }
 584                         else
 585                         {
 586                                 overlayPhysicalRect.width += (overlayRegionWidthUnit - modW);
 587                         }
 588                         modified = true;
 589                 }
 590         }
 591
 592         base = overlayRegionHeightUnit / 2;
 593         if (base != 0)
 594         {
 595                 int modH = overlayPhysicalRect.height % overlayRegionHeightUnit;
 596                 if (modH != 0)
 597                 {
 598                         if (modH <= base)
 599                         {
 600                                 overlayPhysicalRect.height -= modH;
 601                         }
 602                         else
 603                         {
 604                                 overlayPhysicalRect.height += (overlayRegionHeightUnit - modH);
 605                         }
 606                         modified = true;
 607                 }
 608         }
 609
 610         Rectangle rect = _CoordinateSystemUtils::InverseTransform(overlayPhysicalRect);
 611         if (rect.width != userRect.width || rect.height != userRect.height )
 612         {
 613                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] __InvR(overlayPhysicalRect [%d, %d, %d, %d]) (w : %4d, h : %4d) org (w : %4d, h : %4d) is not same",
 614                                 overlayPhysicalRect.x, overlayPhysicalRect.y, overlayPhysicalRect.width, overlayPhysicalRect.height, rect.width,  rect.height, userRect.width, userRect.height);
 615                 return E_INVALID_ARG;
 616         }
 617
 618         // First, overlayPhysicalRect's x, y position should be positive value or zero.
 619         if (!((overlayPhysicalRect.x >= 0) && (overlayPhysicalRect.y >= 0) &&
 620               // Second, Check if it is clipping or not. (OverlayRegion cannot be clipped)
 621                   (overlayPhysicalRect.x + overlayPhysicalRect.width <= basePhysicalRect.x + basePhysicalRect.width) &&
 622                   (overlayPhysicalRect.y + overlayPhysicalRect.height <= basePhysicalRect.y + basePhysicalRect.height)))
 623         {
 624                 SysLogException(NID_UI_CTRL, E_INVALID_ARG, "[E_INVALID_ARG] The bounds of OverlayRegion is now outside of the current form "
 625                                                                                         "overlayPhysicalRect (x : %4d, y: %4d, w : %4d, h : %4d), "
 626                                                                                         "basePhysicalRect (x : %4d, y: %4d, w : %4d, h : %4d).",
 627                                  overlayPhysicalRect.x, overlayPhysicalRect.y, overlayPhysicalRect.width, overlayPhysicalRect.height,
 628                                  basePhysicalRect.x, basePhysicalRect.y, basePhysicalRect.width, basePhysicalRect.height);
 629                 r = E_INVALID_ARG;
 630         }
 631
 632 //      SysLog(NID_UI_CTRL, " overlayPhysicalRect [%d, %d, %d, %d], basePhysicalRect [%d, %d, %d, %d] modified[%d]",
 633 //                       overlayPhysicalRect.x, overlayPhysicalRect.y, overlayPhysicalRect.width, overlayPhysicalRect.height,
 634 //                       basePhysicalRect.x, basePhysicalRect.y, basePhysicalRect.width, basePhysicalRect.height, modified );
 635
 636         return r;
 637 }
 638
 639 result
 640 _OverlayRegionImpl::SetPixelFormatList(void)
 641 {
 642 #ifndef _OSP_EMUL_
 643         String formatList;
 644
 645         result r = E_SUCCESS;
 646         _RegistryImpl _reg;
 647
 648         r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 649         if (IsFailed(r))
 650         {
 651                 if (r == E_OUT_OF_MEMORY)
 652                 {
 653                         SysTryReturn(NID_UI_CTRL, r != E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 654                 }
 655                 else
 656                 {
 657                         SysAssertf(0, "failed to Construct the _RegistryImpl");
 658                 }
 659         }
 660
 661         r = _reg.GetValue(_UI_INFO_SESSION, L"OverlayRegionBufferPixelFormat", formatList);
 662         SysAssertf(!IsFailed(r), "Failed to get a registry value");
 663
 664         SysLog(NID_UI_CTRL,"FormatList: %ls", formatList.GetPointer());
 665 #else
 666         String formatList(L"ARGB8888/RGB565/YCbCr420P");
 667 #endif
 668
 669         bool set = false;
 670         if (formatList.Contains(L"ARGB8888"))
 671         {
 672                 overlayRegionPixelFomatList[OVERLAY_REGION_BUFFER_PIXEL_FORMAT_ARGB8888] = true;
 673                 set = true;
 674         }
 675
 676         if (formatList.Contains(L"RGB565"))
 677         {
 678                 overlayRegionPixelFomatList[OVERLAY_REGION_BUFFER_PIXEL_FORMAT_RGB565] = true;
 679                 set = true;
 680         }
 681
 682         if (formatList.Contains(L"YCbCr420P"))
 683         {
 684                 overlayRegionPixelFomatList[OVERLAY_REGION_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR] = true;
 685                 set = true;
 686         }
 687
 688         if (formatList.Contains(L"NV12"))
 689         {
 690                 overlayRegionPixelFomatList[OVERLAY_REGION_BUFFER_PIXEL_FORMAT_NV12] = true;
 691                 set = true;
 692         }
 693
 694         if (formatList.Contains(L"UYVY"))
 695         {
 696                 overlayRegionPixelFomatList[OVERLAY_REGION_BUFFER_PIXEL_FORMAT_UYVY] = true;
 697                 set = true;
 698         }
 699
 700         SysAssertf(set, "registry file is something wrong");
 701
 702         overlayRegionPixelFomatList[0] = set;
 703
 704         return E_SUCCESS;
 705 }
 706
 707 int
 708 _OverlayRegionImpl::GetWidthUnit(void)
 709 {
 710         ClearLastResult();
 711
 712         if (_OverlayRegionImpl::overlayRegionWidthUnit == -1)
 713         {
 714                 result r = E_SUCCESS;
 715                 _RegistryImpl _reg;
 716                 String value;
 717                 int val;
 718
 719                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 720                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
 721
 722                 r = _reg.GetValue(_UI_INFO_SESSION, L"OverlayRegionWidthUnit", value);
 723                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
 724
 725                 r = Integer::Parse(value, val);
 726                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
 727
 728                 _OverlayRegionImpl::overlayRegionWidthUnit = val;
 729
 730                 SysLog(NID_UI_CTRL, "overlayRegionWidthUnit : %d", _OverlayRegionImpl::overlayRegionWidthUnit);
 731         }
 732
 733         SetLastResult(E_SUCCESS);
 734
 735         return _OverlayRegionImpl::overlayRegionWidthUnit;
 736 }
 737
 738 int
 739 _OverlayRegionImpl::GetHeightUnit(void)
 740 {
 741         ClearLastResult();
 742
 743         if (_OverlayRegionImpl::overlayRegionHeightUnit == -1)
 744         {
 745                 result r = E_SUCCESS;
 746                 _RegistryImpl _reg;
 747                 String value;
 748                 int val;
 749
 750                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 751                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
 752
 753                 r = _reg.GetValue(_UI_INFO_SESSION, L"OverlayRegionHeightUnit", value);
 754                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
 755
 756                 r = Integer::Parse(value, val);
 757                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
 758
 759                 _OverlayRegionImpl::overlayRegionHeightUnit = val;
 760
 761                 SysLog(NID_UI_CTRL, "overlayRegionHeightUnit : %d", _OverlayRegionImpl::overlayRegionHeightUnit);
 762         }
 763
 764         SetLastResult(E_SUCCESS);
 765
 766         return _OverlayRegionImpl::overlayRegionHeightUnit;
 767 }
 768
 769 int
 770 _OverlayRegionImpl::GetMaxCount(void)
 771 {
 772         ClearLastResult();
 773
 774         if (_OverlayRegionImpl::overlayRegionMaxCount == -1)
 775         {
 776                 result r = E_SUCCESS;
 777                 _RegistryImpl _reg;
 778                 String value;
 779                 int val;
 780
 781                 r = _reg.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 782                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] RegistryImpl construct Failed");
 783
 784                 r = _reg.GetValue(_UI_INFO_SESSION, L"MaxOverlayRegionCount", value);
 785                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Registry GetValue Failed");
 786
 787                 r = Integer::Parse(value, val);
 788                 SysTryReturn(NID_UI_CTRL, !IsFailed(r), -1, E_SYSTEM, "[E_SYSTEM] Parse Failed");
 789
 790                 _OverlayRegionImpl::overlayRegionMaxCount = val;
 791
 792                 SysLog(NID_UI_CTRL, "overlayRegionMaxCount : %d", _OverlayRegionImpl::overlayRegionMaxCount);
 793         }
 794
 795         SetLastResult(E_SUCCESS);
 796
 797         return _OverlayRegionImpl::overlayRegionMaxCount;
 798 }
 799
 800  _OverlayRegionImpl*
 801 _OverlayRegionImpl::GetInstance(OverlayRegion& overlayRegion)
 802 {
 803         return (&overlayRegion != null) ? overlayRegion.__pOverlayRegionImpl : null;
 804 }
 805
 806 const _OverlayRegionImpl*
 807 _OverlayRegionImpl::GetInstance(const OverlayRegion& overlayRegion)
 808 {
 809         return (&overlayRegion != null) ? overlayRegion.__pOverlayRegionImpl : null;
 810 }
 811
 812 } } } // Tizen::Ui::Controls
 813
 814
 815 //////////////////////////////////////////////////////////////////////////////////////
 816 namespace
 817 {
 818
 819 _OverlayRegionMediaCapability::_OverlayRegionMediaCapability(void)
 820         : cameraPrimaryDirection(0)
 821         , cameraPrimaryRotation(0)
 822         , cameraSecondaryDirection(0)
 823         , cameraSecondaryRotation(0)
 824 {
 825 }
 826
 827 _OverlayRegionMediaCapability::~_OverlayRegionMediaCapability(void)
 828 {
 829 }
 830
 831 result
 832 _OverlayRegionMediaCapability::Construct(void)
 833 {
 834         result r = E_SUCCESS;
 835         long long length = 0;
 836         int readLen = 0;
 837         char* pXmlBuffer = null;
 838         Tizen::Base::String key;
 839         Tizen::Base::String fileName;
 840         FileAttributes attributes;
 841         File fileObj;
 842
 843         fileName = _MEDIA_CAPABILITY_FILE_PATH;
 844         SysLog(NID_UI_CTRL, "Capability XML path:%ls", fileName.GetPointer());
 845
 846         r = File::GetAttributes(fileName, attributes);
 847         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 848
 849         length = attributes.GetFileSize();
 850         SysTryReturnResult(NID_UI_CTRL, length > 0, E_SYSTEM, "[E_SYSTEM] the file[%s] size is zero.", fileName.GetPointer());
 851
 852         pXmlBuffer = new (std::nothrow) char[length];
 853         SysTryReturnResult(NID_UI_CTRL, pXmlBuffer != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pXmlBuffer is null");
 854
 855         r = fileObj.Construct(fileName, L"r");
 856         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 857
 858 //      read the capability xml file content as parse the capability
 859         readLen = fileObj.Read(pXmlBuffer, length);
 860         SysTryCatch(NID_UI_CTRL, readLen == length, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM]  length:%d, readLen:%d", length, readLen);
 861
 862 //      parse the capability file buffer all the parse key value pair shall be added in __pMap object
 863         r = ParseCapability(pXmlBuffer, readLen);
 864         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 865
 866         if (pXmlBuffer)
 867         {
 868                 delete[] pXmlBuffer;
 869         }
 870
 871         return E_SUCCESS;
 872
 873 CATCH:
 874         if (pXmlBuffer)
 875         {
 876                 delete[] pXmlBuffer;
 877         }
 878
 879         return r;
 880 }
 881
 882 void
 883 _OverlayRegionMediaCapability::ParseSection(xmlNodePtr pRoot, const String& section)
 884 {
 885         xmlNode* pNode = null;
 886
 887         for (pNode = pRoot->children; pNode; pNode = pNode->next)
 888         {
 889                 String name((char*)pNode->name);
 890                 String key(section);
 891
 892                 key += "." + name;
 893
 894                 if (pNode->type == XML_ELEMENT_NODE && pNode->children)
 895                 {
 896                         if (key.Equals(String(_CAM_PRIMARY_DIRECTION)))
 897                         {
 898                                 //SysLog(NID_UI_CTRL,"@@@@@ key:%ls, %s", key.GetPointer(), (wchar_t*)pNode->children->content);
 899                                 String direction((char*)pNode->children->content);
 900                                 if (direction.Equals(String("Back")))
 901                                         cameraPrimaryDirection = 2;//CAMERA_DIRECTION_BACK;
 902                                 else
 903                                         cameraPrimaryDirection = 1;//CAMERA_DIRECTION_FRONT;
 904                         }
 905                         else if (key.Equals(String(_CAM_PRIMARY_ROTATION)))
 906                         {
 907                                 //SysLog(NID_UI_CTRL,"@@@@@ key:%ls, %s", key.GetPointer(), (wchar_t*)pNode->children->content );
 908                                 String rot((char*)pNode->children->content);
 909                                 int ret = 0 ;
 910                                 Integer::Decode(rot, ret);
 911                                 cameraPrimaryRotation = (ret / 90) + 1;
 912                         }
 913                         else if (key.Equals(String(_CAM_SECONDARY_DIRECTION)))
 914                         {
 915                                 //SysLog(NID_UI_CTRL,"@@@@@ key:%ls, %s", key.GetPointer(), (wchar_t*)pNode->children->content );
 916                                 String direction((char*)pNode->children->content);
 917                                 if (direction.Equals(String("Back")))
 918                                         cameraSecondaryDirection = 2;//CAMERA_DIRECTION_BACK;
 919                                 else
 920                                         cameraSecondaryDirection = 1;//CAMERA_DIRECTION_FRONT;
 921                         }
 922                         else if (key.Equals(String(_CAM_SECONDARY_ROTATION)))
 923                         {
 924                                 //SysLog(NID_UI_CTRL,"@@@@@ key:%ls, %s", key.GetPointer(), (wchar_t*)pNode->children->content );
 925                                 String rot((char*)pNode->children->content);
 926                                 int ret = 0 ;
 927                                 Integer::Decode(rot, ret);
 928                                 cameraSecondaryRotation = (ret / 90) + 1;
 929                         }
 930                 }
 931
 932                 ParseSection(pNode, key);
 933         }
 934 }
 935
 936 result
 937 _OverlayRegionMediaCapability::ParseCapability(const char* xmlBuffer, int length)
 938 {
 939         xmlDoc* pDoc = null;
 940         xmlNode* pRoot = null;
 941         xmlNode* pNode = null;
 942
 943         result r = E_SUCCESS;
 944         String name;
 945
 946         pDoc = xmlParseMemory(xmlBuffer, length);
 947         SysTryReturnResult(NID_UI_CTRL, pDoc != null, E_SYSTEM, "[E_SYSTEM] xmlParseMemory failed %s %d", xmlBuffer, length);
 948
 949         pRoot = xmlDocGetRootElement(pDoc);
 950         SysTryCatch(NID_UI_CTRL, pRoot != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] xmlDocGetRootElement failed");
 951
 952         name = (const char*) (pRoot->name);
 953         SysTryCatch(NID_UI_CTRL, name.Equals("MediaCapability", true), r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Invalid Root Name %ls", name.GetPointer());
 954
 955         for (pNode = pRoot->children; pNode; pNode = pNode->next)
 956         {
 957                 if (pNode->type == XML_ELEMENT_NODE)
 958                 {
 959                         String nodeName((char*)pNode->name);
 960                         ParseSection(pNode, nodeName);
 961                 }
 962         }
 963
 964         xmlFreeDoc(pDoc);
 965         return E_SUCCESS;
 966
 967 CATCH:
 968         if (pDoc)
 969         {
 970                 xmlFreeDoc(pDoc);
 971         }
 972
 973         return r;
 974 }
 975
 976 }