src/ui/controls/FUiCtrl_OverlayAgent.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_OverlayAgent.cpp
  20  * @brief               This file contains implementation of _OverlayAgent class
  21  */
  22
  23 #include <new>
  24 #include <sys/shm.h>
  25 #include <unique_ptr.h>
  26
  27 #define OVERLAY_PIXMAP_DUMP 0
  28
  29 #if OVERLAY_PIXMAP_DUMP
  30 extern "C"{
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <X11/Xproto.h>
  34
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <dri2.h>
  38 #include <tbm_bufmgr.h>
  39 #include <xf86drm.h>
  40 }
  41 #endif //OVERLAY_PIXMAP_DUMP
  42
  43 #include <Ecore_Evas.h>
  44
  45 #include <FBaseResult.h>
  46 #include <FUiIOrientationEventListener.h>
  47 #include <FGrp_BufferInfoImpl.h>
  48 #include <FGrp_Screen.h>
  49 #include <FIo_RegistryImpl.h>
  50 #include <FMedia_ImageUtil.h>
  51 #include "FUi_Control.h"
  52 #include "FUi_CoordinateSystemUtils.h"
  53 #include "FUi_EcoreEvas.h"
  54 #include "FUi_EcoreEvasMgr.h"
  55 #include "FUiAnim_EflNode.h"
  56 #include "FUiAnim_ControlVisualElement.h"
  57 #include "FUiAnim_VisualElementSurfaceImpl.h"
  58 #include "FUiAnim_VisualElementImpl.h"
  59 #include "FUiCtrl_OverlayAgent.h"
  60
  61 #define B(c,s) ((((unsigned int)(c)) & 0xff) << (s))
  62 #define FOURCC(a,b,c,d) (B(d,24) | B(c,16) | B(b,8) | B(a,0))
  63
  64 using namespace std;
  65 using namespace Tizen::Base;
  66 using namespace Tizen::Base::Collection;
  67 using namespace Tizen::Graphics;
  68 using namespace Tizen::Io;
  69 using namespace Tizen::Media;
  70 using namespace Tizen::System;
  71 using namespace Tizen::Ui::Controls;
  72 using namespace Tizen::Ui::Animations;
  73
  74 namespace
  75 {
  76 const int _ROTATION_0 = 0;
  77 const int _ROTATION_90 = 90;
  78 const int _ROTATION_180 = 180;
  79 const int _ROTATION_270 = 270;
  80 const int _ROTATION_360 = 360;
  81
  82 #if OVERLAY_PIXMAP_DUMP
  83
  84 tbm_bufmgr gTbmBufmgr = null;
  85 int gFileCount = 0;
  86 int gDrmFd = -1;
  87
  88 void
  89 dump_bmp(const char* pFileName, const void* pData, int width, int height)
  90 {
  91         FILE* pFile = null;
  92
  93         struct
  94         {
  95                 unsigned char magic[2];
  96         } bmpfile_magic = { {'B', 'M'} };
  97
  98         struct
  99         {
 100                 unsigned int filesz;
 101                 unsigned short creator1;
 102                 unsigned short creator2;
 103                 unsigned int bmp_offset;
 104         } bmpfile_header = { 0, 0, 0, 0x36 };
 105
 106         struct
 107         {
 108                 unsigned int header_sz;
 109                 unsigned int width;
 110                 unsigned int height;
 111                 unsigned short nplanes;
 112                 unsigned short bitspp;
 113                 unsigned int compress_type;
 114                 unsigned int bmp_bytesz;
 115                 unsigned int hres;
 116                 unsigned int vres;
 117                 unsigned int ncolors;
 118                 unsigned int nimpcolors;
 119         } bmp_dib_v3_header_t = { 0x28, 0, 0, 1, 24, 0, 0, 0, 0, 0, 0 };
 120
 121         if (pFileName != null)
 122         {
 123                 pFile = fopen(pFileName, "w+");
 124         }
 125
 126         if (pFile == null)
 127         {
 128                 SysSecureLog(NID_UI_CTRL,"Failed to open %s", pFileName);
 129                 return;
 130         }
 131
 132         bmpfile_header.filesz = sizeof(bmpfile_magic) + sizeof(bmpfile_header) + sizeof(bmp_dib_v3_header_t) + width * height * 3;
 133         bmp_dib_v3_header_t.header_sz = sizeof(bmp_dib_v3_header_t);
 134         bmp_dib_v3_header_t.width = width;
 135         bmp_dib_v3_header_t.height = -height;
 136         bmp_dib_v3_header_t.nplanes = 1;
 137         bmp_dib_v3_header_t.bmp_bytesz = width * height * 3;
 138
 139         fwrite(&bmpfile_magic, sizeof(bmpfile_magic), 1, pFile);
 140         fwrite(&bmpfile_header, sizeof(bmpfile_header), 1, pFile);
 141         fwrite(&bmp_dib_v3_header_t, sizeof(bmp_dib_v3_header_t), 1, pFile);
 142
 143         unsigned int* pBlocks = (unsigned int*)pData;
 144
 145         for (int i = 0; i < (height * width); i++)
 146         {
 147                 fwrite(&pBlocks[i], 3, 1, pFile);
 148         }
 149         fclose(pFile);
 150
 151         return;
 152 }
 153
 154 tbm_bufmgr
 155 bufmgr_get(Display* pDisplay, Pixmap pixmap)
 156 {
 157         int screen = DefaultScreen(pDisplay);
 158
 159         // DRI2
 160         int eventBase = 0;
 161         int errorBase = 0;
 162         if (!DRI2QueryExtension(pDisplay, &eventBase, &errorBase))
 163         {
 164                 SysSecureLog(NID_UI_CTRL, "Failed to get value of DRI2QueryExtension.");
 165                 return null;
 166         }
 167
 168         int dri2Major = 0;
 169         int dri2Minor = 0;
 170         if (!DRI2QueryVersion(pDisplay, &dri2Major, &dri2Minor))
 171         {
 172                 SysSecureLog(NID_UI_CTRL, "Failed to get value of DRI2QueryVersion.");
 173                 return null;
 174         }
 175
 176         char* pDriverName = null;
 177         char* pDeviceName = null;
 178         if (!DRI2Connect(pDisplay, RootWindow(pDisplay, screen), &pDriverName, &pDeviceName))
 179         {
 180                 SysSecureLog(NID_UI_CTRL, "Failed to get value of DRI2Connect.");
 181                 return null;
 182         }
 183
 184         SysSecureLog(NID_UI_CTRL, "The current name of open drm device is %s.", pDeviceName);
 185
 186         // Get the drm_fd though opening the deviceName
 187         gDrmFd = open(pDeviceName, O_RDWR);
 188         if (gDrmFd < 0)
 189         {
 190                 SysSecureLog(NID_UI_CTRL, "Failed to open drm device (%s)", pDeviceName);
 191                 return null;
 192         }
 193
 194         // Get the drm magic
 195         drm_magic_t magic;
 196         drmGetMagic(gDrmFd, &magic);
 197         if (!DRI2Authenticate(pDisplay, RootWindow(pDisplay, screen), magic))
 198         {
 199                 SysSecureLog(NID_UI_CTRL, "Failed to get value of DRI2Authenticate.");
 200                 close(gDrmFd);
 201                 gDrmFd = -1;
 202                 return null;
 203         }
 204
 205         // tbm buffer manager init
 206         tbm_bufmgr bufmgr = tbm_bufmgr_init(gDrmFd);
 207         if (!bufmgr)
 208         {
 209                 SysSecureLog(NID_UI_CTRL, "Failed to initialize buffer manager.");
 210                 close(gDrmFd);
 211                 gDrmFd = -1;
 212                 return null;
 213         }
 214
 215         DRI2CreateDrawable(pDisplay, pixmap);
 216
 217         return bufmgr;
 218 }
 219
 220 static void
 221 pixmap_update (Display* pDisplay, tbm_bufmgr bufmgr, Pixmap pixmap, int x, int y, int width, int height)
 222 {
 223         int dri2_width = 0;
 224         int dri2_height = 0;
 225         unsigned int attachments[1] = { DRI2BufferFrontLeft };
 226         int dri2_count = 1;
 227         int dri2_out_count = 0;
 228
 229         int opt = TBM_OPTION_READ|TBM_OPTION_WRITE;
 230         char imgFile[100] = {0,};
 231
 232         tbm_bo bo;
 233         tbm_bo_handle bo_handle;
 234
 235         DRI2Buffer* pDri2_buffers = DRI2GetBuffers (pDisplay, pixmap, &dri2_width, &dri2_height, attachments, dri2_count, &dri2_out_count);
 236         SysTryLogCatch(NID_UI_CTRL, pDri2_buffers != null, , "Failed to get buffers.");
 237         SysTryLogCatch(NID_UI_CTRL, pDri2_buffers[0].name != null, , "Failed to get a handle of the dri2 buffer.");
 238
 239         SysSecureLog(NID_UI_CTRL, "The current name of Dri2_buffers[0] is %d.", pDri2_buffers[0].name);
 240
 241         bo = tbm_bo_import(bufmgr, pDri2_buffers[0].name);
 242         SysTryLogCatch(NID_UI_CTRL, bo != null, , "Failed to import bo (key : %d).", pDri2_buffers[0].name);
 243
 244         bo_handle = tbm_bo_map(bo, TBM_DEVICE_CPU, opt);
 245         SysTryLogCatch(NID_UI_CTRL, bo_handle.ptr != null, , "Failed to get map.");
 246
 247         memset(imgFile, 0, sizeof(imgFile));
 248         sprintf(imgFile,"./dump%d.bmp", gFileCount++);
 249
 250         if (gFileCount == 5 || gFileCount == 20)
 251         {
 252                 dump_bmp(imgFile, bo_handle.ptr, dri2_width, dri2_height);
 253         }
 254
 255 CATCH:
 256         if (bo_handle.ptr)
 257         {
 258                 tbm_bo_unmap(bo);
 259         }
 260
 261         if (bo)
 262         {
 263                 tbm_bo_unref(bo);
 264         }
 265
 266         if (pDri2_buffers)
 267         {
 268                 free(pDri2_buffers);
 269         }
 270 }
 271 #endif // OVERLAY_PIXMAP_DUMP
 272
 273 bool
 274 _CheckXvExtension(Display* pDisplay, int* pFirstPort, int* pCountPort)
 275 {
 276         unsigned int version = 0;
 277         unsigned int release = 0;
 278         unsigned int requestBase = 0;
 279         unsigned int eventBase = 0;
 280         unsigned int errorBase = 0;
 281
 282         // Query and print Xvideo properties
 283         int returnValue = XvQueryExtension(pDisplay, &version, &release, &requestBase, &eventBase, &errorBase);
 284         if (returnValue != Success)
 285         {
 286                 if (returnValue == XvBadExtension)
 287                 {
 288                         SysSecureLog(NID_UI_CTRL, "XvBadExtension returned at XvQueryExtension!");
 289                 }
 290                 else if (returnValue == XvBadAlloc)
 291                 {
 292                         SysSecureLog(NID_UI_CTRL, "XvBadAlloc returned at XvQueryExtension!");
 293                 }
 294                 else
 295                 {
 296                         SysSecureLog(NID_UI_CTRL, "Other error happened at XvQueryExtension!");
 297                 }
 298
 299                 return false;
 300         }
 301
 302 //      SysLog(NID_UI_CTRL, "========================================");
 303 //      SysLog(NID_UI_CTRL, "XvQueryExtension returned the following:");
 304 //      SysLog(NID_UI_CTRL, "version      : %u", version);
 305 //      SysLog(NID_UI_CTRL, "release      : %u", release);
 306 //      SysLog(NID_UI_CTRL, "request_base : %u", requestBase);
 307 //      SysLog(NID_UI_CTRL, "event_base   : %u", eventBase);
 308 //      SysLog(NID_UI_CTRL, "error_base   : %u", errorBase);
 309 //      SysLog(NID_UI_CTRL, "========================================");
 310
 311         unsigned int adaptors = 0;
 312         XvAdaptorInfo* pAdaptorInfo = null;
 313         returnValue = XvQueryAdaptors(pDisplay, DefaultRootWindow(pDisplay), &adaptors, &pAdaptorInfo);
 314         if (returnValue != Success)
 315         {
 316                 if (returnValue == XvBadExtension)
 317                 {
 318                         SysSecureLog(NID_UI_CTRL, "XvBadExtension returned at XvQueryExtension.");
 319                 }
 320                 else if (returnValue == XvBadAlloc)
 321                 {
 322                         SysSecureLog(NID_UI_CTRL, "XvBadAlloc returned at XvQueryExtension.");
 323                 }
 324                 else
 325                 {
 326                         SysSecureLog(NID_UI_CTRL, "Other error happaned at XvQueryAdaptors.");
 327                 }
 328
 329                 if (pAdaptorInfo != null)
 330                 {
 331                         XvFreeAdaptorInfo(pAdaptorInfo);
 332                 }
 333
 334                 return false;
 335         }
 336
 337 //      SysLog(NID_UI_CTRL, "XvQueryAdaptors returned the following:");
 338 //      SysLog(NID_UI_CTRL, "%d adaptors available.", adaptors);
 339
 340         int port = -1;
 341         if (adaptors > 0 && pAdaptorInfo != null)
 342         {
 343                 for (unsigned int i = 0; i < adaptors; i++)
 344                 {
 345         //              SysLog(NID_UI_CTRL, " name:        %s"
 346         //                                                              " type:        %s%s%s%s%s"
 347         //                                                              " first port:  %ld"
 348         //                                                              " ports:       %ld",
 349         //                                      pAdaptorInfo[i].name,
 350         //                                      (pAdaptorInfo[i].type & XvInputMask) ? "input | " : "",
 351         //                                      (pAdaptorInfo[i].type & XvOutputMask) ? "output | " : "",
 352         //                                      (pAdaptorInfo[i].type & XvVideoMask) ? "video | " : "",
 353         //                                      (pAdaptorInfo[i].type & XvStillMask) ? "still | " : "",
 354         //                                      (pAdaptorInfo[i].type & XvImageMask) ? "image | " : "",
 355         //                                      pAdaptorInfo[i].base_id,
 356         //                                      pAdaptorInfo[i].num_ports);
 357         //              SysLog(NID_UI_CTRL, " format list: %d", i);
 358
 359                         for (unsigned int j = 0; j < pAdaptorInfo[i].num_formats; j++)
 360                         {
 361                                 SysSecureLog(NID_UI_CTRL, "The current value of depth is %d and visual is %ld.",
 362                                         pAdaptorInfo[i].formats[j].depth, pAdaptorInfo[i].formats[j].visual_id);
 363                         }
 364                 }
 365
 366                 port = pAdaptorInfo[0].base_id;
 367
 368                 *pFirstPort = port;
 369                 *pCountPort = pAdaptorInfo[0].num_ports;
 370                 SysSecureLog(NID_UI_CTRL, "The current value of port is %d", port);
 371         }
 372
 373         if (pAdaptorInfo != null)
 374         {
 375                 XvFreeAdaptorInfo(pAdaptorInfo);
 376         }
 377
 378         if (port == -1)
 379         {
 380                 return false;
 381         }
 382
 383         return true;
 384 }
 385
 386 Eina_Bool
 387 OnPixmapDamaged(void* pData, int type, void* pEvent)
 388 {
 389         Tizen::Ui::Controls::_OverlayAgent* pOverlayAgent = static_cast<Tizen::Ui::Controls::_OverlayAgent*>(pData);
 390
 391         Ecore_X_Event_Damage* pDamageEvent = (Ecore_X_Event_Damage*)pEvent;
 392         SysTryReturn(NID_UI_CTRL, pDamageEvent != null, ECORE_CALLBACK_PASS_ON, E_INVALID_DATA, "[E_INVALID_DATA] The current value of DamageEvent is an invalid.");
 393
 394         Pixmap pixmap = pOverlayAgent->GetPixmap();
 395         if (pDamageEvent->drawable != pixmap)
 396         {
 397                 SysSecureLog(NID_UI_CTRL, "The current drawable[%d] is not for this overlay agent's pixmap[%d]", pDamageEvent->drawable, pixmap);
 398                 return ECORE_CALLBACK_PASS_ON;
 399         }
 400
 401         Evas_Object* pImageObject = pOverlayAgent->GetPixmapImageObject();
 402         SysTryReturn(NID_UI_CTRL, pImageObject != null, ECORE_CALLBACK_PASS_ON, E_INVALID_DATA, "[E_INVALID_DATA] The current value of ImageObject is an invalid.");
 403
 404         int w = 0;
 405         int h = 0;
 406         evas_object_geometry_get(pImageObject, null, null, &w, &h);
 407         //evas_object_image_pixels_dirty_set(pImageObject, 1);
 408         //evas_object_image_fill_set(pImageObject, 0, 0, w, h);
 409         evas_object_image_filled_set(pImageObject, EINA_TRUE);
 410         evas_object_image_data_update_add(pImageObject, 0, 0, w, h);
 411
 412 #if OVERLAY_PIXMAP_DUMP
 413
 414         if (gDrmFd > -1)
 415         {
 416                 close(gDrmFd);
 417                 gDrmFd = -1;
 418         }
 419
 420         if (gTbmBufmgr)
 421         {
 422                 tbm_bufmgr_deinit(gTbmBufmgr);
 423                 gTbmBufmgr = null;
 424         }
 425
 426         if (gTbmBufmgr == null)
 427         {
 428                 gTbmBufmgr = bufmgr_get((Display*)ecore_x_display_get(), pixmap);
 429         }
 430
 431         if (gTbmBufmgr != null)
 432         {
 433                 pixmap_update((Display*)ecore_x_display_get(), gTbmBufmgr, pixmap, 0, 0, w, h);
 434         }
 435         else
 436         {
 437                 SysSecureLog(NID_UI_CTRL, "can't get pixmap gBufmgr");
 438         }
 439
 440         SysSecureLog(NID_UI_CTRL, "dump pixmap[%d]", pixmap);
 441
 442 #endif // OVERLAY_PIXMAP_DUMP
 443
 444         return ECORE_CALLBACK_DONE;
 445 }
 446
 447 void
 448 OnEvasImageDamaged(void* pData, Evas_Object* pImageObject)
 449 {
 450         Tizen::Ui::Controls::_OverlayAgent* pOverlayAgent = static_cast<Tizen::Ui::Controls::_OverlayAgent*>(pData);
 451
 452         Evas_Object* pMyImageObject = pOverlayAgent->GetPixmapImageObject();
 453         SysTryReturn(NID_UI_CTRL, pMyImageObject != null, , E_INVALID_DATA, "[E_INVALID_DATA] The current value of ImageObject is an invalid.");
 454
 455         if (pMyImageObject == pImageObject)
 456         {
 457                 Dimension curImgDim(0,0);
 458                 evas_object_image_size_get(pImageObject, &curImgDim.width, &curImgDim.height);
 459
 460                 Dimension orgImgDim = pOverlayAgent->GetPrevCbImageDimension();
 461                 if (!orgImgDim.Equals(curImgDim))
 462                 {
 463                         SysSecureLog(NID_UI_CTRL,"org[%d, %d] cur[%d, %d]", orgImgDim.width, orgImgDim.height, curImgDim.width, curImgDim.height);
 464                         pOverlayAgent->SetPrevCbImageDimension(curImgDim);
 465                         pOverlayAgent->SetEvasImageDirtyFlag(false);
 466                 }
 467
 468                 if(!(pOverlayAgent->GetEvasImageDirtyFlag()))
 469                 {
 470                         pOverlayAgent->AdjustImageObject();
 471                         pOverlayAgent->SetEvasImageDirtyFlag(true);
 472                 }
 473         }
 474 }
 475
 476 } // Anonymous
 477
 478 namespace Tizen { namespace Ui { namespace Controls
 479 {
 480 int _OverlayAgent::__overlayAgentXvPortCount = 0;
 481 int _OverlayAgent::__baseXvPort = 0;
 482 bool _OverlayAgent::__isPortGrapped[]={false,};
 483
 484 int _OverlayAgent::__overlayAgentcount = 0;
 485 int _OverlayAgent::__dstRectMinWidth = -1;
 486 int _OverlayAgent::__dstRectMinHegith = -1;
 487 int _OverlayAgent::__srcRectMinWidth = -1;
 488 int _OverlayAgent::__srcRectMinHegith = -1;
 489 int _OverlayAgent::__overlayWidthUnit = -1;
 490 int _OverlayAgent::__overlayHeightUnit = -1;
 491 int _OverlayAgent::__overlayMaxCount = -1;
 492 bool _OverlayAgent::__OverlayAgentBufferPixelFormat[] = {false, };
 493
 494 _OverlayAgent*
 495 _OverlayAgent::CreateInstanceN(_OverlayAgentStyle style, const _Control& control, const FloatRectangle& logBounds, const Rectangle& phyBounds)
 496 {
 497         unique_ptr<_OverlayAgent> pOverlayAgent(new (std::nothrow) _OverlayAgent(style, control, logBounds, phyBounds));
 498         SysTryReturn(NID_UI_CTRL, pOverlayAgent, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 499
 500         result r = GetLastResult();
 501         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 502
 503         return pOverlayAgent.release();
 504 }
 505
 506 _OverlayAgent::_OverlayAgent(_OverlayAgentStyle style, const _Control& control, const FloatRectangle& logBounds, const Rectangle& bounds)
 507         : __pImageObject(null)
 508         , __pRenderImageObject(null)
 509         , __pSmartObject(null)
 510         , __pixmapDamageHandle(0)
 511         , __pPixmapEventHandler(null)
 512         , __pixmap(0)
 513         , __pVisualElement(null)
 514         , __bgColor(0xff000000)
 515         , __xvPort(-1)
 516         , __grabXvPort(false)
 517         , __colorFormat(0)
 518         , __userRotation(_ROTATION_0)
 519         , __flushRotate(false)
 520         , __udMirroring(0)
 521         , __lrMirroring(0)
 522         , __aspectRatio(false)
 523         , __srcDimension(0, 0)
 524         , __pixmapPhyRect(0, 0, 0, 0)
 525         , __resizeRect(0, 0, 0, 0)
 526         , __style(style)
 527         , __pXvImage(null)
 528         , __newColorFormat(0)
 529         , __pShmInfo(null)
 530         , __overlayAgentColorFormat(_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888)
 531         , __pRefUserByteBuffer(null)
 532         , __pOrgUserByteBuffer(null)
 533         , __orgUsrImgDimension(0, 0)
 534         , __orgCbImgDimension(0, 0)
 535         , __logicalOverlayRect(logBounds)
 536         , __evasImageDamaged(false)
 537 {
 538         result r = E_SUCCESS;
 539
 540         switch(style)
 541         {
 542         case _OVERLAY_AGENT_STYLE_REGION_SW:
 543                 //fall through
 544         case _OVERLAY_AGENT_STYLE_REGION_GL:
 545                 r = CreateImageObjectForOverlayRegion(control, bounds);
 546                 break;
 547
 548         case _OVERLAY_AGENT_STYLE_PANEL_GL:
 549                 //fall through
 550         case _OVERLAY_AGENT_STYLE_PANEL_SW:
 551                 r = CreateImageObject(control, bounds);
 552                 break;
 553
 554         default:
 555                 r = E_INVALID_ARG;
 556         }
 557
 558         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 559         SysTryReturnVoidResult(NID_UI_CTRL, __pVisualElement != null, E_SYSTEM, "[E_SYSTEM] The VisualElement is null.");
 560
 561         __overlayAgentcount++;
 562         SysLog(NID_UI_CTRL, "The overlayAgentcount in Constructor is [%d]", __overlayAgentcount);
 563 }
 564
 565 _OverlayAgent::~_OverlayAgent(void)
 566 {
 567         SysLog(NID_UI_CTRL, "The overlayAgentcount in Destructor is [%d] and deleted.", __overlayAgentcount);
 568         __overlayAgentcount--;
 569
 570         UngrabXvPort();
 571
 572         if (__pPixmapEventHandler)
 573         {
 574                 ecore_event_handler_del(__pPixmapEventHandler);
 575                 __pPixmapEventHandler = null;
 576         }
 577
 578         if (__pixmapDamageHandle)
 579         {
 580                 ecore_x_damage_free(__pixmapDamageHandle);
 581                 __pixmapDamageHandle = 0;
 582         }
 583
 584         if (__pixmap != 0)
 585         {
 586                 XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
 587                 __pixmap = 0;
 588         }
 589
 590         if (__pShmInfo)
 591         {
 592                 XShmDetach((Display*)ecore_x_display_get(), __pShmInfo);
 593                 shmdt(__pShmInfo->shmaddr);
 594                 shmctl(__pShmInfo->shmid, IPC_RMID, NULL);
 595                 __pShmInfo = null;
 596         }
 597
 598         if (__pXvImage)
 599         {
 600                 XFree(__pXvImage);
 601                 __pXvImage = null;
 602         }
 603
 604         if (__pOrgUserByteBuffer)
 605         {
 606                 delete __pOrgUserByteBuffer;
 607                 __pOrgUserByteBuffer = null;
 608         }
 609
 610         if (__pImageObject)
 611         {
 612                 evas_object_smart_member_del(__pImageObject);
 613                 evas_object_del(__pImageObject);
 614                 __pImageObject = null;
 615         }
 616
 617         if (__pRenderImageObject)
 618         {
 619                 evas_object_smart_member_del(__pRenderImageObject);
 620                 evas_object_del(__pRenderImageObject);
 621                 __pRenderImageObject = null;
 622         }
 623
 624         if ((__style == _OVERLAY_AGENT_STYLE_REGION_SW || __style == _OVERLAY_AGENT_STYLE_REGION_GL)
 625                         && (__pVisualElement != null))
 626         {
 627                 __pVisualElement->Destroy();
 628                 __pVisualElement = null;
 629         }
 630
 631 #if OVERLAY_PIXMAP_DUMP
 632
 633         if (gDrmFd > -1)
 634         {
 635                 close(gDrmFd);
 636                 gDrmFd = -1;
 637         }
 638
 639         if (gTbmBufmgr)
 640         {
 641                 tbm_bufmgr_deinit(gTbmBufmgr);
 642                 gTbmBufmgr = null;
 643         }
 644
 645 #endif //OVERLAY_PIXMAP_DUMP
 646
 647 }
 648
 649 result
 650 _OverlayAgent::Draw(void)
 651 {
 652         SysTryReturnResult(NID_UI_CTRL, __pRefUserByteBuffer->GetPointer() != null, E_SYSTEM, "The current user buffer is null. (nothing to draw)");
 653
 654         result r = E_SUCCESS;
 655         if(__style == _OVERLAY_AGENT_STYLE_REGION_SW || __style == _OVERLAY_AGENT_STYLE_PANEL_SW)
 656         {
 657                 r = PutEvasImage();
 658         }
 659         else
 660         {
 661                 r = PutXvImage();
 662         }
 663         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
 664
 665         return r;
 666 }
 667
 668 result
 669 _OverlayAgent::GetBufferInfo(BufferInfo& bufferInfo) const
 670 {
 671         int w = 0, h = 0;
 672         evas_object_geometry_get(__pImageObject, NULL, NULL, &w, &h);
 673
 674         bufferInfo.width = w;
 675         bufferInfo.pitch = w;
 676         bufferInfo.height = h;
 677         bufferInfo.bitsPerPixel = 32;
 678         bufferInfo.pixelFormat = PIXEL_FORMAT_ARGB8888;
 679
 680         _BufferInfoImpl* pBufferInfoImpl = _BufferInfoImpl::GetInstance(bufferInfo);
 681
 682         if(__style == _OVERLAY_AGENT_STYLE_REGION_SW || __style == _OVERLAY_AGENT_STYLE_PANEL_SW)
 683         {
 684                 pBufferInfoImpl->SetHandle(_BufferInfoImpl::HANDLE_TYPE_VE_SURFACE, reinterpret_cast<Handle>(__pImageObject));
 685                 SysSecureLog(NID_UI_CTRL,"return evas image object");
 686         }
 687         else
 688         {
 689                 pBufferInfoImpl->SetHandle(_BufferInfoImpl::HANDLE_TYPE_OVERLAY_REGION, __pixmap);
 690                 SysSecureLog(NID_UI_CTRL,"return pixmap ID");
 691         }
 692
 693         pBufferInfoImpl->SetBounds(Rectangle(0, 0, w, h));
 694
 695         return E_SUCCESS;
 696 }
 697
 698 result
 699 _OverlayAgent::SetInputBuffer(const ByteBuffer& srcBuffer, const Dimension& srcDim, _OverlayAgentBufferPixelFormat srcFormat)
 700 {
 701         SysTryReturn(NID_UI_CTRL, srcBuffer.GetPointer() != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The srcBuffer which is input parameter is invalid.");
 702         SysTryReturn(NID_UI_CTRL, srcBuffer.GetCapacity() > 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The srcBuffer which is input parameter is invalid.");
 703         SysTryReturn(NID_UI_CTRL, IsValidSourceDimension(srcDim), E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The srcDim which is input parameter is invalid.");
 704
 705         switch (srcFormat)
 706         {
 707         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888:
 708                 __newColorFormat = FOURCC('R','G','B','4');
 709                 break;
 710         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_RGB565:
 711                 __newColorFormat = FOURCC('R','G','B','P');
 712                 break;
 713         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR:
 714                 __newColorFormat = FOURCC('I','4','2','0');
 715                 break;
 716         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_NV12:
 717                 __newColorFormat = FOURCC('N','V','1','2');
 718                 break;
 719         case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY:
 720                 __newColorFormat = FOURCC('U','Y','V','Y');
 721                 break;
 722         default:
 723                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "The specified pixel format is not supported.");
 724                 return E_UNSUPPORTED_FORMAT;
 725         }
 726
 727         __srcDimension.width = srcDim.width;
 728         __srcDimension.height = srcDim.height;
 729
 730         __overlayAgentColorFormat = srcFormat;
 731         __pRefUserByteBuffer = &srcBuffer;
 732
 733         SysLog(NID_UI_CTRL,"The current value of buffer is %x, size is %d, new color format is %x",
 734                 __pRefUserByteBuffer->GetPointer(), __pRefUserByteBuffer->GetCapacity(), __newColorFormat);
 735
 736         return E_SUCCESS;
 737 }
 738
 739 result
 740 _OverlayAgent::SetRotation(_OverlayAgentRotation rotation)
 741 {
 742         SysTryReturnResult(NID_UI_CTRL, (rotation < _OVERLAY_AGENT_ROTATION_MAX), E_INVALID_ARG,
 743                                                 "[E_INVALID_ARG)] The rotation which is input parameter(%d) is invalid.", rotation);
 744
 745         int rotate = _ROTATION_0;
 746
 747         switch (rotation)
 748         {
 749         case _OVERLAY_AGENT_ROTATION_NONE:
 750                 // fall through
 751         case _OVERLAY_AGENT_ROTATION_NONE_LR:
 752                 // fall through
 753         case _OVERLAY_AGENT_ROTATION_NONE_UD:
 754                 rotate = _ROTATION_0;
 755                 break;
 756
 757         case _OVERLAY_AGENT_ROTATION_90:
 758                 // fall through
 759         case _OVERLAY_AGENT_ROTATION_90_LR:
 760                 // fall through
 761         case _OVERLAY_AGENT_ROTATION_90_UD:
 762                 rotate = _ROTATION_90;
 763                 break;
 764
 765         case _OVERLAY_AGENT_ROTATION_180:
 766                 // fall through
 767         case _OVERLAY_AGENT_ROTATION_180_LR:
 768                 // fall through
 769         case _OVERLAY_AGENT_ROTATION_180_UD:
 770                 rotate = _ROTATION_180;
 771                 break;
 772
 773         case _OVERLAY_AGENT_ROTATION_270:
 774                 // fall through
 775         case _OVERLAY_AGENT_ROTATION_270_LR:
 776                 // fall through
 777         case _OVERLAY_AGENT_ROTATION_270_UD:
 778                 rotate = _ROTATION_270;
 779                 break;
 780
 781         default:
 782                 rotate = _ROTATION_0;
 783                 break;
 784         }
 785
 786         int udMirroring = 0;
 787         int lrMirroring = 0;
 788
 789         switch (rotation)
 790         {
 791         case _OVERLAY_AGENT_ROTATION_NONE_UD:
 792                 // fall through
 793         case _OVERLAY_AGENT_ROTATION_90_UD:
 794                 // fall through
 795         case _OVERLAY_AGENT_ROTATION_180_UD:
 796                 // fall through
 797         case _OVERLAY_AGENT_ROTATION_270_UD:
 798                 udMirroring = 1;
 799                 lrMirroring = 0;
 800                 break;
 801         case _OVERLAY_AGENT_ROTATION_NONE_LR:
 802                 // fall through
 803         case _OVERLAY_AGENT_ROTATION_90_LR:
 804                 // fall through
 805         case _OVERLAY_AGENT_ROTATION_180_LR:
 806                 // fall through
 807         case _OVERLAY_AGENT_ROTATION_270_LR:
 808                 udMirroring = 0;
 809                 lrMirroring = 1;
 810                 break;
 811         default:
 812                 udMirroring = 0;
 813                 lrMirroring = 0;
 814                 break;
 815         }
 816
 817         __userRotation = rotate;
 818         __udMirroring = udMirroring;
 819         __lrMirroring = lrMirroring;
 820         __flushRotate = true;
 821
 822         result r = AdjustImageObject();
 823         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 824         SysLog(NID_UI_CTRL, "The current value of userRotation is %d, udMirroring is %d, lrMirroring is %d", __userRotation, __udMirroring, __lrMirroring);
 825
 826         return E_SUCCESS;
 827 }
 828
 829 result
 830 _OverlayAgent::SetDestination(const FloatDimension& dimension)
 831 {
 832         FloatDimension phyDimF = _CoordinateSystemUtils::Transform(dimension);
 833         Dimension phyDim = _CoordinateSystemUtils::ConvertToInteger(phyDimF);
 834
 835         __resizeRect.width = phyDim.width;
 836         __resizeRect.height = phyDim.height;
 837         SysSecureLog(NID_UI_CTRL, "The current value of resizeRect is (%d, %d, %d, %d)",__resizeRect.x, __resizeRect.y, __resizeRect.width, __resizeRect.height);
 838
 839         result r = AdjustImageObject();
 840         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 841
 842         return r;
 843 }
 844
 845 result
 846 _OverlayAgent::SetAspectRatio(bool enable)
 847 {
 848         __aspectRatio = enable;
 849
 850         return E_SUCCESS;
 851 }
 852
 853 result
 854 _OverlayAgent::CreateImageObjectForOverlayRegion(const _Control& control, const Rectangle& phyBounds)
 855 {
 856         _EflNode* pEflNode = null;
 857         Evas_Object* pSmartObject = null;
 858         Evas* pEvas = null;
 859         Ecore_Evas* pEcoreEvas = null;
 860         VisualElementSurface* pVisualElementSurface = null;
 861         _VisualElementSurfaceImpl* pVisualElementSurfaceImpl = null;
 862         Evas_Object* pTemp = null;
 863
 864         // 1. make VE for OR
 865         _VisualElement* pParentVE = control.GetVisualElement();
 866         SysTryReturn(NID_UI_CTRL, pParentVE != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] pParentVE is null.");
 867
 868         _VisualElementImpl* pVisualElementImpl = null;
 869         _VisualElement* pVisualElement = new (std::nothrow) _VisualElement();
 870
 871         SysTryReturn(NID_UI_CTRL, pVisualElement != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pVisualElement : Memory shortage.");
 872
 873         result r = pVisualElement->Construct();
 874         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r) );
 875
 876         pVisualElement->SetName("OverlayRegion");
 877         pVisualElement->SetShowState(true);
 878 //      pVisualElement->SetOpacity(1.0f);
 879         pVisualElement->SetImplicitAnimationEnabled(false);
 880 //      pVisualElement->SetBackgroundColor(_Colorf(0.0f, 0.0f, 0.0f, 0.0f));
 881
 882         pVisualElementImpl = _VisualElementImpl::GetInstance(*pVisualElement);
 883
 884         pVisualElementImpl->SetZOrderGroup(_CONTROL_LAYER_OVERLAY);
 885         r = pParentVE->InsertChild(*pVisualElement, null, true);
 886
 887         pVisualElement->SetBounds(__logicalOverlayRect);
 888
 889         // 2. remove origin VE image object buffer
 890         pVisualElementSurface = pVisualElementImpl->GetSurfaceN();
 891         SysTryCatch(NID_UI_CTRL, pVisualElementSurface != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurface is null" );
 892
 893         pVisualElementSurfaceImpl = _VisualElementSurfaceImpl::GetInstance(*pVisualElementSurface);
 894         SysTryCatch(NID_UI_CTRL, pVisualElementSurfaceImpl != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurfaceImpl is null" );
 895
 896         pTemp = (Evas_Object*)pVisualElementSurfaceImpl->GetNativeHandle();
 897         SysTryCatch(NID_UI_CTRL, pTemp != null, , E_SYSTEM, "[E_SYSTEM] pTemp is null" );
 898
 899         evas_object_image_data_set(pTemp, NULL);
 900         delete pVisualElementSurface;
 901
 902         // 3. create image object
 903         pEflNode = dynamic_cast<_EflNode*>(pVisualElement->GetNativeNode());
 904         SysTryCatch(NID_UI_CTRL, pEflNode != null, , E_SYSTEM, "[E_SYSTEM] pEflNode is null" );
 905
 906         pSmartObject = (Evas_Object*)pEflNode->GetGroupContainer();
 907         SysTryCatch(NID_UI_CTRL, pSmartObject != null, , E_SYSTEM, "[E_SYSTEM] pSmartObject is null" );
 908
 909         __pSmartObject = pSmartObject;
 910
 911         pEvas = evas_object_evas_get(pSmartObject);
 912         SysTryCatch(NID_UI_CTRL, pEvas != null, , E_SYSTEM, "[E_SYSTEM] pEvas is null" );
 913
 914         pEcoreEvas = ecore_evas_ecore_evas_get(pEvas);
 915         SysTryCatch(NID_UI_CTRL, pEcoreEvas != null, , E_SYSTEM, "[E_SYSTEM] pEcoreEvas is null" );
 916
 917         __pImageObject = evas_object_image_add(pEvas);
 918         SysTryCatch(NID_UI_CTRL, __pImageObject != null, , E_SYSTEM, "[E_SYSTEM] __pImageObject is null" );
 919         evas_object_name_set(__pImageObject, "OverlayRegionImageObj");
 920
 921         // 4. add image obj to smart object
 922         evas_object_smart_member_add(__pImageObject, pSmartObject);
 923         //evas_object_lower(__pImageObject);
 924
 925         SysSecureLog(NID_UI_CTRL, "phyBounds [%d, %d, %d, %d]", phyBounds.x, phyBounds.y, phyBounds.width, phyBounds.height);
 926
 927         evas_object_image_size_set(__pImageObject, phyBounds.width, phyBounds.height);
 928         evas_object_image_filled_set(__pImageObject, EINA_TRUE);
 929         evas_object_image_alpha_set(__pImageObject, false);
 930         evas_object_resize(__pImageObject, phyBounds.width, phyBounds.height);
 931         evas_object_move(__pImageObject, phyBounds.x, phyBounds.y);
 932         evas_object_show(__pImageObject);
 933
 934         r = pVisualElement->SetFlushNeeded();
 935         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 936
 937         __pVisualElement = pVisualElement;
 938
 939         SysSecureLog(NID_UI_CTRL, "ImageObjectForOverlayRegion SUCCESS  __pImageObject : %x, pSmartObject : %x", __pImageObject, pSmartObject);
 940
 941         return E_SUCCESS;
 942
 943 CATCH:
 944         if (__pImageObject)
 945         {
 946                 evas_object_del(__pImageObject);
 947                 __pImageObject = null;
 948         }
 949
 950         if (pVisualElementSurface)
 951         {
 952                 delete pVisualElementSurface;
 953                 pVisualElementSurface = null;
 954         }
 955
 956         if (pVisualElement)
 957         {
 958                 pVisualElement->Destroy();
 959                 pVisualElement = null;
 960         }
 961
 962         return E_SYSTEM;
 963 }
 964
 965 result
 966 _OverlayAgent::CreateImageObject(const _Control& control, const Rectangle& phyBounds)
 967 {
 968         VisualElementSurface* pVisualElementSurface = null;
 969         _VisualElementSurfaceImpl* pVisualElementSurfaceImpl = null;
 970         _VisualElement* pVisualElement = null;
 971         _VisualElementImpl* pVisualElementImpl = null;
 972         Evas* pEvas = null;
 973         Evas_Object* pTemp = null;
 974
 975         _EflNode* pEflNode = dynamic_cast<_EflNode*>(control.GetVisualElement()->GetNativeNode());
 976         SysTryReturn(NID_UI_CTRL, pEflNode != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pEflNode is null.");
 977
 978         Evas_Object* pSmartObject = (Evas_Object*)pEflNode->GetGroupContainer();
 979         SysTryReturn(NID_UI_CTRL, pSmartObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pSmartObject is null.");
 980         __pSmartObject = pSmartObject;
 981
 982         pVisualElement = control.GetVisualElement();
 983         SysTryReturn(NID_UI_CTRL, pVisualElement != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pVisualElement is null.");
 984
 985         pVisualElementImpl = _VisualElementImpl::GetInstance(*pVisualElement);
 986         SysTryReturn(NID_UI_CTRL, pVisualElementImpl != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pVisualElementImpl is null.");
 987
 988         pVisualElementSurface = pVisualElementImpl->GetSurfaceN();
 989         SysTryCatch(NID_UI_CTRL, pVisualElementSurface != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurface is null" );
 990
 991         pVisualElementSurfaceImpl = _VisualElementSurfaceImpl::GetInstance(*pVisualElementSurface);
 992         SysTryCatch(NID_UI_CTRL, pVisualElementSurfaceImpl != null, , E_SYSTEM, "[E_SYSTEM] pVisualElementSurfaceImpl is null" );
 993
 994         pTemp = (Evas_Object*)pVisualElementSurfaceImpl->GetNativeHandle();
 995         SysTryCatch(NID_UI_CTRL, pTemp != null, , E_SYSTEM, "[E_SYSTEM] pTemp is null" );
 996
 997         evas_object_image_data_set(pTemp, NULL);
 998         delete pVisualElementSurface;
 999         pVisualElementSurface = null;
1000
1001         pEvas = evas_object_evas_get(pSmartObject);
1002         SysTryReturn(NID_UI_CTRL, pEvas != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pEvas is null" );
1003
1004         // create renderRect object
1005         __pRenderImageObject = evas_object_rectangle_add(pEvas);
1006         evas_object_name_set(__pRenderImageObject, "OverlayPanelRenderRect");
1007         SysTryReturn(NID_UI_CTRL, __pRenderImageObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pRenderImageObject is null");
1008         evas_object_smart_member_add(__pRenderImageObject, pSmartObject);
1009         evas_object_color_set(__pRenderImageObject, 0, 0, 0, 255); // 100% opaque black
1010         evas_object_resize(__pRenderImageObject, phyBounds.width, phyBounds.height);
1011         evas_object_move(__pRenderImageObject, phyBounds.x, phyBounds.y);
1012         evas_object_show(__pRenderImageObject);
1013
1014         // create image object
1015         __pImageObject = evas_object_image_add(pEvas);
1016         //__pImageObject = evas_object_image_filled_add(pEvas);
1017         SysTryCatch(NID_UI_CTRL, __pImageObject != null, , E_SYSTEM, "[E_SYSTEM] __pImageObject is null");
1018
1019         evas_object_smart_member_add(__pImageObject, pSmartObject);
1020         evas_object_name_set(__pImageObject, "OverlayPanelImageObj");
1021         evas_object_image_size_set(__pImageObject, phyBounds.width, phyBounds.height);
1022         //evas_object_image_fill_set(__pImageObject, 0, 0, phyBounds.width, phyBounds.height);
1023         evas_object_image_alpha_set(__pImageObject, false);
1024         evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1025         evas_object_resize(__pImageObject, phyBounds.width, phyBounds.height);
1026         evas_object_move(__pImageObject, phyBounds.x, phyBounds.y);
1027         evas_object_show(__pImageObject);
1028
1029         __pVisualElement = control.GetVisualElement();
1030
1031         return E_SUCCESS;
1032
1033 CATCH:
1034
1035         if (pVisualElementSurface)
1036         {
1037                 delete pVisualElementSurface;
1038                 pVisualElementSurface = null;
1039         }
1040
1041         if (__pRenderImageObject)
1042         {
1043                 evas_object_del(__pRenderImageObject);
1044                 __pRenderImageObject = null;
1045         }
1046
1047         return E_SYSTEM;
1048 }
1049
1050 result
1051 _OverlayAgent::CreatePixmap(void)
1052 {
1053         SysTryReturnResult(NID_UI_CTRL, __pImageObject != null, E_SYSTEM, "[E_SYSTEM] __pImageObject is null");
1054
1055         int x = 0;
1056         int y = 0;
1057         int w = 0;
1058         int h = 0;
1059
1060         evas_object_geometry_get(__pImageObject, &x, &y, &w, &h);
1061         SysSecureLog(NID_UI_CTRL,"__pImageObject rect is [%d, %d, %d, %d]", x, y, w, h);
1062
1063         Rectangle phyRect(x, y, w, h);
1064         SysTryReturnResult(NID_UI_CTRL, (phyRect.width >= GetDstRectMinWidth()) && (phyRect.height >= GetDstRectMinHeight()), E_SYSTEM, "[E_SYSTEM] can't make a pixmap. dimension[%d, %d] is not proper",phyRect.width, phyRect.height);
1065
1066 // Create pixmap.
1067         Display *pDisplay = (Display*)ecore_x_display_get();
1068         SysTryReturnResult(NID_UI_CTRL, pDisplay != null, E_SYSTEM, "[E_SYSTEM] pDisplay is null");
1069
1070         __pixmap = XCreatePixmap(pDisplay, DefaultRootWindow(pDisplay), phyRect.width, phyRect.height, DefaultDepth(pDisplay, DefaultScreen(pDisplay)));
1071         SysTryReturnResult(NID_UI_CTRL, __pixmap != 0, E_SYSTEM, "[E_SYSTEM] failed to create a pixmap");
1072
1073         GC gc = XCreateGC(pDisplay, __pixmap, 0,0);
1074         SysTryReturnResult(NID_UI_CTRL, gc > 0, E_SYSTEM, "[E_SYSTEM] failed to create GC");
1075
1076         XSetForeground(pDisplay, gc, (long unsigned int)(__bgColor.GetRGB32()));
1077         XFillRectangle(pDisplay, __pixmap, gc, 0, 0, phyRect.width, phyRect.height);
1078         XSync(pDisplay, 0);
1079         XFreeGC(pDisplay, gc);
1080
1081 // Set native surface.
1082         Evas_Native_Surface surf = {0,};
1083
1084         surf.version = EVAS_NATIVE_SURFACE_VERSION;
1085         surf.type = EVAS_NATIVE_SURFACE_X11;
1086         surf.data.x11.visual = ecore_x_default_visual_get(ecore_x_display_get(), ecore_x_default_screen_get());
1087         surf.data.x11.pixmap = __pixmap;
1088
1089         evas_object_lower(__pImageObject);
1090         if (__style == _OVERLAY_AGENT_STYLE_PANEL_SW || __style == _OVERLAY_AGENT_STYLE_PANEL_GL)
1091         {
1092                 if(__pRenderImageObject)
1093                 {
1094                         evas_object_lower(__pRenderImageObject);
1095                 }
1096         }
1097
1098         evas_object_image_native_surface_set(__pImageObject, &surf);
1099
1100 // Create damage.
1101         __pixmapDamageHandle = ecore_x_damage_new(__pixmap, ECORE_X_DAMAGE_REPORT_RAW_RECTANGLES);
1102         SysTryCatch(NID_UI_CTRL, __pixmapDamageHandle != 0, , E_SYSTEM, "[E_SYSTEM] failed to create a damage object");
1103
1104         __pPixmapEventHandler = ecore_event_handler_add(ECORE_X_EVENT_DAMAGE_NOTIFY, OnPixmapDamaged, (void*)this);
1105         SysTryCatch(NID_UI_CTRL, __pPixmapEventHandler != null, , E_SYSTEM, "[E_SYSTEM] failed to add a pixmap damage event handle");
1106
1107         __pixmapPhyRect = Rectangle(0, 0, phyRect.width, phyRect.height);
1108
1109         SysSecureLog(NID_UI_CTRL, "__pixmap : %d.", __pixmap);
1110
1111         return E_SUCCESS;
1112
1113 CATCH:
1114         if (__pPixmapEventHandler)
1115         {
1116                 ecore_event_handler_del(__pPixmapEventHandler);
1117                 __pPixmapEventHandler = null;
1118         }
1119
1120         if (__pixmapDamageHandle)
1121         {
1122                 ecore_x_damage_free(__pixmapDamageHandle);
1123                 __pixmapDamageHandle = 0;
1124         }
1125
1126         if (__pixmap)
1127         {
1128                 XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
1129                 __pixmap = 0;
1130         }
1131
1132         return E_SYSTEM;
1133 }
1134
1135 Pixmap
1136 _OverlayAgent::GetPixmap(void) const
1137 {
1138         return __pixmap;
1139 }
1140
1141 Evas_Object*
1142 _OverlayAgent::GetPixmapImageObject(void) const
1143 {
1144         return __pImageObject;
1145 }
1146
1147 result
1148 _OverlayAgent::Show(void) const
1149 {
1150         return E_SUCCESS;
1151 }
1152
1153 result
1154 _OverlayAgent::GrabXvPort(void)
1155 {
1156         int firstXvPort = -1;
1157         int portCount = -1;
1158
1159         Display* pDisplay = (Display*)ecore_x_display_get();
1160         SysTryReturn(NID_UI_CTRL, pDisplay != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
1161
1162         if (!_CheckXvExtension(pDisplay, &firstXvPort, &portCount))
1163         {
1164                 SysTryReturn(NID_UI_CTRL, false, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] _CheckXvExtension is failed.");
1165         }
1166
1167         SysTryReturn(NID_UI_CTRL, firstXvPort != -1, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] first XvPort[%d] is invalid.", firstXvPort);
1168         SysTryReturn(NID_UI_CTRL, portCount >= 1 && portCount <= _OVERLAYAGENT_XV_PORT , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] portCount[%d] is invalid.", portCount);
1169
1170         _OverlayAgent::__baseXvPort = firstXvPort;
1171
1172         int i, tempPort = 0;
1173         for (i = 0; i < portCount; i++)
1174         {
1175                 if(!__isPortGrapped[i])
1176                 {
1177                         tempPort = firstXvPort + i;
1178                         if (XvGrabPort(pDisplay, tempPort, 0) != Success)
1179                         {
1180                                 SysSecureLog(NID_UI_CTRL, "this port[%d] is alreadly used by another process", tempPort);
1181                         }
1182                         else
1183                         {
1184                                 __xvPort = tempPort;
1185                                 __grabXvPort = true;
1186                                 __isPortGrapped[i] = true;
1187                                 break;
1188                         }
1189                 }
1190         }
1191
1192         SysTryReturn(NID_UI_CTRL, __xvPort != -1 , E_SYSTEM, E_SYSTEM, "XvGrabPort fail for pixmap : %d", __pixmap);
1193
1194         SysSecureLog(NID_UI_CTRL, "XvGrabPort port: %d pixmap: %d style: %d", __xvPort, __pixmap, __style);
1195
1196         __overlayAgentXvPortCount++;
1197
1198         return E_SUCCESS;
1199 }
1200
1201 result
1202 _OverlayAgent::PutXvImage(void)
1203 {
1204         SysTryReturnResult(NID_UI_CTRL, __pixmap != 0, E_SYSTEM, "[E_SYSTEM] __pixmap is invalid. something wrong!");
1205
1206         Display* pDisplay = (Display*)ecore_x_display_get();
1207         SysTryReturn(NID_UI_CTRL, pDisplay != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pDisplay is null.");
1208
1209         GC gc = DefaultGCOfScreen(DefaultScreenOfDisplay(pDisplay));
1210
1211         bool needRealloc = false;
1212         Dimension usrDim(__srcDimension.width,__srcDimension.height);
1213         if (__pXvImage == null
1214                         || __newColorFormat != __colorFormat
1215                         || !usrDim.Equals(__orgUsrImgDimension) /*|| __pXvImage->data_size != __pRefUserByteBuffer->GetCapacity()*/)
1216         {
1217                 needRealloc = true;
1218
1219                 if (__xvPort != -1)
1220                 {
1221                                 SysSecureLog(NID_UI_CTRL, "Need to unGrap port[%d]!", __xvPort);
1222                                 UngrabXvPort();
1223                 }
1224
1225                 if(__pXvImage != null)
1226                 {
1227                         SysSecureLog(NID_UI_CTRL,"pXvImage->data_size : %d, userBufferSize : %d", __pXvImage->data_size, __pRefUserByteBuffer->GetCapacity());
1228                         SysSecureLog(NID_UI_CTRL,"__newColorFormat : %x, __colorFormat : %x", __newColorFormat, __colorFormat);
1229
1230                         if (__pShmInfo)
1231                         {
1232                                 XShmDetach(pDisplay, __pShmInfo);
1233                                 shmdt(__pShmInfo->shmaddr);
1234                                 shmctl(__pShmInfo->shmid, IPC_RMID, NULL);
1235                                 delete __pShmInfo;
1236                                 __pShmInfo = null;
1237                         }
1238
1239                         if (__pXvImage)
1240                         {
1241                                 XFree(__pXvImage);
1242                                 __pXvImage = null;
1243                         }
1244                 }
1245                 else
1246                 {
1247                         SysSecureLog(NID_UI_CTRL, "__pXvImage is null!");
1248                 }
1249         }
1250
1251         if (__xvPort == -1)
1252         {
1253                 SysSecureLog(NID_UI_CTRL, "port[%d] is invalid!", __xvPort);
1254                 result r = GrabXvPort();
1255                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r) );
1256         }
1257
1258         if (needRealloc)
1259         {
1260                 XvImage* pXvImage = null;
1261                 XShmSegmentInfo* pShmInfo = null;
1262
1263                 pShmInfo = new (std::nothrow) XShmSegmentInfo();
1264                 if (pShmInfo == null)
1265                 {
1266                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM]pShmInfo is null.");
1267                         return E_SYSTEM;
1268                 }
1269
1270                 pXvImage = XvShmCreateImage(pDisplay, __xvPort, __newColorFormat, 0, __srcDimension.width, __srcDimension.height, pShmInfo);
1271                 SysTryReturn(NID_UI_CTRL, pXvImage != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] failed to create a XvImage.");
1272
1273                 pShmInfo->shmid = shmget(IPC_PRIVATE, pXvImage->data_size, IPC_CREAT | 0777);
1274                 pShmInfo->shmaddr = pXvImage->data = (char*)shmat(pShmInfo->shmid, 0, 0);
1275                 pShmInfo->readOnly = False;
1276
1277                 if (!XShmAttach(pDisplay, pShmInfo))
1278                 {
1279                         XFree(pXvImage);
1280                         SysLogException(NID_UI_CTRL, E_SYSTEM, "[E_SYSTEM] failed to XShmAttach.");
1281                         return E_SYSTEM;
1282                 }
1283
1284                 __pXvImage = pXvImage;
1285                 __pShmInfo = pShmInfo;
1286                 __colorFormat = __newColorFormat;
1287         }
1288
1289         memcpy(__pXvImage->data, __pRefUserByteBuffer->GetPointer(), __pXvImage->data_size);
1290         __pRefUserByteBuffer = null;
1291         __orgUsrImgDimension = usrDim;
1292
1293         XvShmPutImage(pDisplay, __xvPort, __pixmap, gc, __pXvImage, 0, 0, __srcDimension.width, __srcDimension.height,
1294                         __pixmapPhyRect.x, __pixmapPhyRect.y, __pixmapPhyRect.width, __pixmapPhyRect.height, False);
1295
1296         XSync(pDisplay, 0);
1297
1298         SysSecureLog(NID_UI_CTRL, "colorFormat : %x, src[%d,%d,%d, %d], dst [%d,%d,%d,%d]", __colorFormat, 0, 0, __srcDimension.width, __srcDimension.height,__pixmapPhyRect.x, __pixmapPhyRect.y, __pixmapPhyRect.width, __pixmapPhyRect.height);
1299
1300         return E_SUCCESS;
1301 }
1302
1303 result
1304 _OverlayAgent::PutEvasImage(void)
1305 {
1306         SysTryReturn(NID_UI_CTRL, __pImageObject, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pImageObject is null.");
1307         SysTryReturn(NID_UI_CTRL, __pRefUserByteBuffer->GetPointer(), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] __pUserBuffer is null.");
1308
1309         result r = E_SYSTEM;
1310
1311         Dimension usrDim(__srcDimension.width,__srcDimension.height);
1312         if(!usrDim.Equals(__orgUsrImgDimension) || __pOrgUserByteBuffer == null)
1313         {
1314                 if(__pOrgUserByteBuffer)
1315                 {
1316                         __pOrgUserByteBuffer->SetPosition(0);
1317                         delete __pOrgUserByteBuffer;
1318                         __pOrgUserByteBuffer = null;
1319                 }
1320
1321                 int bufSize = __srcDimension.width *__srcDimension.height * 4;
1322                 __pOrgUserByteBuffer = new (std::nothrow) ByteBuffer;
1323                 SysTryReturn(NID_UI_CTRL, __pOrgUserByteBuffer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] __pOrgUserByteBuffer is null.");
1324
1325                 r = __pOrgUserByteBuffer->Construct(bufSize);
1326                 if(r != E_SUCCESS)
1327                 {
1328                         SysLogException(NID_UI_CTRL, r, "[%s] Failed to construct a __pOrgUserByteBuffer.", GetErrorMessage(r));
1329                         delete __pOrgUserByteBuffer;
1330                         __pOrgUserByteBuffer = null;
1331                         return r;
1332                 }
1333         }
1334
1335         __pOrgUserByteBuffer->SetPosition(0);
1336
1337         void* pImg = null;
1338         if(__overlayAgentColorFormat == _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888)
1339         {
1340                 r = __pOrgUserByteBuffer->SetArray(__pRefUserByteBuffer->GetPointer(), 0, __pOrgUserByteBuffer->GetCapacity());
1341                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r,"[%s] Propagating.", GetErrorMessage(r));
1342
1343                 pImg = (void*)__pOrgUserByteBuffer->GetPointer();
1344                 //_ImageUtil::ConvertPixelFormat(srcBuffer, MEDIA_PIXEL_FORMAT_RGBA8888, __srcDimension.width, __srcDimension.height, *pDstbuf, MEDIA_PIXEL_FORMAT_RGBA8888);
1345         }
1346         else
1347         {
1348                 switch (__overlayAgentColorFormat)
1349                 {
1350                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_RGB565:
1351                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_RGB565LE, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1352                         break;
1353                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR:
1354                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_YUV420P, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1355                         break;
1356                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_NV12:
1357                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_NV12, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1358                         break;
1359                 case _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY:
1360                         r = _ImageUtil::ConvertPixelFormat(*__pRefUserByteBuffer, MEDIA_PIXEL_FORMAT_UYVY422, __srcDimension.width, __srcDimension.height, *__pOrgUserByteBuffer, MEDIA_PIXEL_FORMAT_BGRA8888);
1361                         break;
1362                 default:
1363                         SysLogException(NID_UI_CTRL, E_UNSUPPORTED_FORMAT, "The specified pixel format is not supported.");
1364                         return E_UNSUPPORTED_FORMAT;
1365                 }
1366
1367                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r,"[%s] Propagating.", GetErrorMessage(r));
1368
1369                 pImg = (void*)(__pOrgUserByteBuffer->GetPointer());
1370
1371         }
1372
1373         SysTryReturnResult(NID_UI_CTRL, pImg != null, E_SYSTEM, "[E_SYSTEM] converted image data is invalid.");
1374
1375 //      SysLog(NID_UI_CTRL, "__pUserBuffer : %x, size : %d", __pRefUserByteBuffer->GetPointer(),  __pRefUserByteBuffer->GetCapacity());
1376 //      SysLog(NID_UI_CTRL, "__pOrgBuffer : %x, size : %d", __pOrgUserByteBuffer->GetPointer(),  __pOrgUserByteBuffer->GetCapacity());
1377 //      SysLog(NID_UI_CTRL, "__srcDimension[%d, %d]",__srcDimension.width, __srcDimension.height);
1378
1379         evas_object_image_size_set(__pImageObject, __srcDimension.width, __srcDimension.height);
1380         evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1381         evas_object_image_alpha_set(__pImageObject, false);
1382         evas_object_image_data_set(__pImageObject, pImg);
1383         evas_object_image_data_update_add(__pImageObject, 0, 0, __srcDimension.width, __srcDimension.height);
1384         evas_object_show(__pImageObject);
1385
1386         AdjustImageObject();
1387
1388         __pVisualElement->SetFlushNeeded();
1389
1390         __orgUsrImgDimension = usrDim;
1391         __pRefUserByteBuffer = null;
1392
1393         return E_SUCCESS;
1394 }
1395
1396 void
1397 _OverlayAgent::UngrabXvPort(void)
1398 {
1399         if (__grabXvPort)
1400         {
1401                 Display* pDisplay = (Display*) ecore_x_display_get();
1402                 Atom atom = XInternAtom(pDisplay, "_USER_WM_PORT_ATTRIBUTE_STREAM_OFF", False);
1403                 XvSetPortAttribute(pDisplay, __xvPort, atom, 1);
1404                 XvUngrabPort(pDisplay, __xvPort, 0);
1405
1406                 SysSecureLog(NID_UI_CTRL, "The current value of UngrabXvPort port is %d, pixmap is %d and style is %d", __xvPort, __pixmap, __style);
1407
1408                 __isPortGrapped[__xvPort-__baseXvPort] = false;
1409                 __xvPort = -1;
1410                 __grabXvPort = false;
1411                 __overlayAgentXvPortCount--;
1412         }
1413 }
1414
1415 bool
1416 _OverlayAgent::IsValidSourceDimension(const Dimension& dimension) const
1417 {
1418         SysTryReturn(NID_UI_CTRL, dimension.width >= GetSrcRectMinWidth(), false, E_INVALID_ARG, "[E_INVALID_ARG] The width of dimension [%d] is under the minimum size.", dimension.width);
1419         SysTryReturn(NID_UI_CTRL, dimension.height >= GetSrcRectMinHeight(), false, E_INVALID_ARG, "[E_INVALID_ARG] The height of dimension [%d] is under the minimum size.", dimension.height);
1420
1421         SetLastResult(E_SUCCESS);
1422
1423         return true;
1424 }
1425
1426 bool
1427 _OverlayAgent::IsValidDestinationDimension(const FloatDimension& dimension) const
1428 {
1429         FloatDimension phyDimF = _CoordinateSystemUtils::Transform(dimension);
1430         Dimension phyDim = _CoordinateSystemUtils::ConvertToInteger(phyDimF);
1431
1432         SysTryReturn(NID_UI_CTRL, (phyDim.width >= GetDstRectMinWidth() && phyDim.height >= GetDstRectMinHeight()), false, E_INVALID_ARG,
1433                         "[E_INVALID_ARG] Dimension L[%.3f, %.3f] P[%d,%d] is over minimun size.", dimension.width, dimension.height, phyDim.width, phyDim.height);
1434
1435         SysTryReturn(NID_UI_CTRL, __pSmartObject != null, false, E_SYSTEM, "[E_SYSTEM] __pSmartObject is null");
1436
1437         FloatRectangle testRect = __pVisualElement->GetBounds();
1438         FloatRectangle containerPhyRectF = _CoordinateSystemUtils::Transform(testRect);
1439         Dimension containerDim = _CoordinateSystemUtils::ConvertToInteger(FloatDimension(containerPhyRectF.width, containerPhyRectF.height));
1440
1441         SysTryReturn(NID_UI_CTRL, (phyDim.width <= containerDim.width && phyDim.height <= containerDim.height), false, E_INVALID_ARG,
1442                         "[E_INVALID_ARG] RenderRect L[%.3f, %.3f] P[%d,%d] is bigger than container size [%d, %d]", dimension.width, dimension.height, phyDim.width, phyDim.height, containerDim.width, containerDim.height);
1443
1444         return true;
1445 }
1446
1447 result
1448 _OverlayAgent::AdjustImageObject(void)
1449 {
1450         SysTryReturn(NID_UI_CTRL, __pSmartObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The SmartObject is null");
1451         SysTryReturn(NID_UI_CTRL, __pImageObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The ImageObject is null");
1452         SysTryReturn(NID_UI_CTRL, __pVisualElement != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] The VisualElement is null");
1453
1454         int x = 0;
1455         int y = 0;
1456         int w = 0;
1457         int h = 0;
1458         int resizeRectX = 0;
1459         int resizeRectY = 0;
1460         int resizeRectW = 0;
1461         int resizeRectH = 0;
1462         int noImage = false;
1463         int imgWidth = 0, imgHeight = 0;
1464         //int orgX, orgY, orgW, orgH;
1465
1466         FloatRectangle curRectF = __pVisualElement->GetBounds();
1467         FloatRectangle curPhyRectF = _CoordinateSystemUtils::Transform(curRectF);
1468         Rectangle curPhyRect = _CoordinateSystemUtils::ConvertToInteger(curPhyRectF);
1469         SysLog(NID_UI_CTRL, "The current value of curPhyRect [%d, %d]", curPhyRect.width, curPhyRect.height);
1470
1471         if (__srcDimension.width == 0 || __srcDimension.height == 0)
1472         {
1473                 SysSecureLog(NID_UI_CTRL, "src dimension[%d, %d] is an initialized state", __srcDimension.width, __srcDimension.height);
1474                 noImage = true;
1475         }
1476
1477         // 1. setting renderRect resize region
1478         if(__resizeRect.width == 0 || __resizeRect.height == 0)
1479         {
1480                 if (__pRenderImageObject)
1481                 {
1482                         evas_object_geometry_get(__pRenderImageObject, NULL, NULL, &resizeRectW, &resizeRectH);
1483                 }
1484                 else
1485                 {
1486                         resizeRectW = curPhyRect.width;
1487                         resizeRectH = curPhyRect.height;
1488                 }
1489         }
1490         else
1491         {
1492                 resizeRectW = __resizeRect.width;
1493                 resizeRectH = __resizeRect.height;
1494         }
1495
1496         // 2. adjust RenderRect
1497         x = curPhyRect.x;
1498         y = curPhyRect.y;
1499         w = curPhyRect.width;
1500         h = curPhyRect.height;
1501         SysSecureLog(NID_UI_CTRL, "container [%d, %d, %d, %d]", x, y, w, h);
1502
1503         if(__pRenderImageObject)
1504         {
1505 //              evas_object_geometry_get(__pRenderImageObject, &orgX, &orgY, &orgW, &orgH);
1506 //              SysLog(NID_UI_CTRL, "renderRect before [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1507
1508                 evas_object_resize(__pRenderImageObject, resizeRectW, resizeRectH);
1509
1510                 resizeRectX = x + ((w - resizeRectW)/2);
1511                 resizeRectY = y + ((h - resizeRectH)/2);
1512                 evas_object_move(__pRenderImageObject, resizeRectX, resizeRectY);
1513                 evas_object_show(__pRenderImageObject);
1514
1515                 SysSecureLog(NID_UI_CTRL, "renderRect [%d, %d, %d, %d]", resizeRectX, resizeRectY, resizeRectW, resizeRectH);
1516
1517 //              evas_object_geometry_get(__pRenderImageObject, &orgX, &orgY, &orgW, &orgH);
1518 //              SysLog(NID_UI_CTRL, "renderRect after adjust [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1519         }
1520         else
1521         {
1522                 //evas_object_geometry_get(__pImageObject, &orgX, &orgY, &orgW, &orgH);
1523                 //SysLog(NID_UI_CTRL, "__pImageObject rect [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1524
1525                 // set region base x, y
1526                 resizeRectX = x;
1527                 resizeRectY = y;
1528         }
1529
1530         SysSecureLog(NID_UI_CTRL, "resizeRect is [%d, %d, %d, %d]", resizeRectX, resizeRectY, resizeRectW, resizeRectH);
1531
1532         if (__flushRotate)
1533         {
1534                 int finalX, finalY, finalW, finalH;
1535
1536                 SysSecureLog(NID_UI_CTRL, "for rotate status operation");
1537
1538                 // 3. image object rotate
1539                 Evas_Map* pMap = evas_map_new(4);
1540                 evas_map_util_points_populate_from_object(pMap, __pImageObject);
1541
1542                 SysSecureLog(NID_UI_CTRL, "center [%d, %d]", resizeRectX + (resizeRectW/2), resizeRectY + (resizeRectH/2));
1543                 evas_map_util_rotate(pMap, __userRotation, resizeRectX + (resizeRectW/2), resizeRectY + (resizeRectH/2));
1544
1545                 evas_object_map_set(__pImageObject, pMap);
1546                 evas_object_map_enable_set(__pImageObject, EINA_TRUE);
1547
1548                 evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1549                 evas_object_show(__pImageObject);
1550                 evas_map_free(pMap);
1551
1552                 SysSecureLog(NID_UI_CTRL, "rotate value is [%d]",__userRotation);
1553
1554                 // 4. reset map coordinate
1555                 if (!noImage && __aspectRatio && __pRenderImageObject != null)
1556                 {
1557                         //  don't do anything for a Render Rect,  only adjust an image object coordination again
1558                         Dimension srcDim(__srcDimension.width, __srcDimension.height);
1559                         if (__userRotation == _ROTATION_90 || __userRotation == _ROTATION_270 )
1560                         {
1561                                 int tmp = srcDim.width;
1562                                 srcDim.width = srcDim.height;
1563                                 srcDim.height = tmp;
1564 //                      SysLog(NID_UI_CTRL, "src dim is swapped");
1565                         }
1566
1567                         SysSecureLog(NID_UI_CTRL, "src dimension [%d, %d]", srcDim.width, srcDim.height);
1568
1569                         float srcRatio = ((float)srcDim.width) / ((float)srcDim.height);
1570
1571                         float tmpWidth = (float)resizeRectW;
1572                         float tmpHeight = tmpWidth / srcRatio;
1573
1574                         if (resizeRectH < (int)tmpHeight)
1575                         {
1576                                 finalH = resizeRectH;
1577                                 finalW = (int)((float)finalH * srcRatio);
1578                         }
1579                         else
1580                         {
1581                                 finalW = resizeRectW;
1582                                 finalH = (int)((float)finalW / srcRatio);
1583                         }
1584
1585                         finalX = resizeRectX + ((resizeRectW - finalW) / 2);
1586                         finalY = resizeRectY + ((resizeRectH - finalH) / 2);
1587                 }
1588                 else
1589                 {
1590                         finalX = resizeRectX;
1591                         finalY = resizeRectY;
1592                         finalW = resizeRectW;
1593                         finalH = resizeRectH;
1594                 }
1595
1596                 //int p1, p2, p3, p4;
1597                 //evas_object_geometry_get(__pImageObject, &p1, &p2, &p3, &p4);
1598                 //SysLog(NID_UI_CTRL, "__pImageObject after rotate [%d, %d, %d, %d]", p1, p2, p3, p4);
1599
1600                 SysSecureLog(NID_UI_CTRL, "final image object [%d, %d, %d, %d]", finalX, finalY, finalW, finalH);
1601
1602                 pMap = evas_map_new(4);
1603                 evas_map_util_points_populate_from_object(pMap, __pImageObject);
1604
1605                 evas_object_image_size_get(__pImageObject, &imgWidth, &imgHeight);
1606                 SysSecureLog(NID_UI_CTRL, "image object size is [%d, %d]", imgWidth, imgHeight);
1607
1608                 switch(__userRotation)
1609                 {
1610                 case _ROTATION_0:
1611                         if(__lrMirroring)
1612                         {
1613                                 evas_map_point_coord_set(pMap, 1, finalX, finalY, 0);
1614                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY, 0);
1615                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY + finalH, 0);
1616                                 evas_map_point_coord_set(pMap, 2, finalX, finalY + finalH, 0);
1617                         }
1618                         else if(__udMirroring)
1619                         {
1620                                 evas_map_point_coord_set(pMap, 3, finalX, finalY, 0);
1621                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY, 0);
1622                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY + finalH, 0);
1623                                 evas_map_point_coord_set(pMap, 0, finalX, finalY + finalH, 0);
1624                         }
1625                         else
1626                         {
1627                                 evas_map_point_coord_set(pMap, 0, finalX, finalY, 0);
1628                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY, 0);
1629                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY + finalH, 0);
1630                                 evas_map_point_coord_set(pMap, 3, finalX, finalY + finalH, 0);
1631                         }
1632                         break;
1633                 case _ROTATION_90:
1634                         if(__lrMirroring)
1635                         {
1636                                 evas_map_point_coord_set(pMap, 2, finalX, finalY, 0);
1637                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY, 0);
1638                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY + finalH, 0);
1639                                 evas_map_point_coord_set(pMap, 3, finalX, finalY + finalH, 0);
1640                         }
1641                         else if(__udMirroring)
1642                         {
1643                                 evas_map_point_coord_set(pMap, 0, finalX, finalY, 0);
1644                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY, 0);
1645                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY + finalH, 0);
1646                                 evas_map_point_coord_set(pMap, 1, finalX, finalY + finalH, 0);
1647                         }
1648                         else
1649                         {
1650                                 evas_map_point_coord_set(pMap, 3, finalX, finalY, 0);
1651                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY, 0);
1652                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY + finalH, 0);
1653                                 evas_map_point_coord_set(pMap, 2, finalX, finalY + finalH, 0);
1654                         }
1655                         break;
1656                 case _ROTATION_180:
1657                         if(__lrMirroring)
1658                         {
1659                                 evas_map_point_coord_set(pMap, 3, finalX, finalY, 0);
1660                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY, 0);
1661                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY + finalH, 0);
1662                                 evas_map_point_coord_set(pMap, 0, finalX, finalY + finalH, 0);
1663                         }
1664                         else if(__udMirroring)
1665                         {
1666                                 evas_map_point_coord_set(pMap, 1, finalX, finalY, 0);
1667                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY, 0);
1668                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY + finalH, 0);
1669                                 evas_map_point_coord_set(pMap, 2, finalX, finalY + finalH, 0);
1670                         }
1671                         else
1672                         {
1673                                 evas_map_point_coord_set(pMap, 2, finalX, finalY, 0);
1674                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY, 0);
1675                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY + finalH, 0);
1676                                 evas_map_point_coord_set(pMap, 1, finalX, finalY + finalH, 0);
1677                         }
1678                         break;
1679                 case _ROTATION_270:
1680                         if(__lrMirroring)
1681                         {
1682                                 evas_map_point_coord_set(pMap, 0, finalX, finalY, 0);
1683                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY, 0);
1684                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY + finalH, 0);
1685                                 evas_map_point_coord_set(pMap, 1, finalX, finalY + finalH, 0);
1686                         }
1687                         else if(__udMirroring)
1688                         {
1689                                 evas_map_point_coord_set(pMap, 2, finalX, finalY, 0);
1690                                 evas_map_point_coord_set(pMap, 1, finalX + finalW, finalY, 0);
1691                                 evas_map_point_coord_set(pMap, 0, finalX + finalW, finalY + finalH, 0);
1692                                 evas_map_point_coord_set(pMap, 3, finalX, finalY + finalH, 0);
1693                         }
1694                         else
1695                         {
1696                                 evas_map_point_coord_set(pMap, 1, finalX, finalY, 0);
1697                                 evas_map_point_coord_set(pMap, 2, finalX + finalW, finalY, 0);
1698                                 evas_map_point_coord_set(pMap, 3, finalX + finalW, finalY + finalH, 0);
1699                                 evas_map_point_coord_set(pMap, 0, finalX, finalY + finalH, 0);
1700                         }
1701                         break;
1702                 default:
1703                         SysSecureLog(NID_UI_CTRL, "__userRotation[%d] is invalid", __userRotation);
1704                         break;
1705                 }
1706
1707                 if(imgWidth > 0 && imgHeight > 0)
1708                 {
1709                         evas_map_point_image_uv_set(pMap, 0, 0, 0);
1710                         evas_map_point_image_uv_set(pMap, 1, imgWidth, 0);
1711                         evas_map_point_image_uv_set(pMap, 2, imgWidth, imgHeight);
1712                         evas_map_point_image_uv_set(pMap, 3, 0, imgHeight);
1713                 }
1714
1715                 evas_object_map_set(__pImageObject, pMap);
1716                 evas_object_map_enable_set(__pImageObject, EINA_TRUE);
1717                 evas_map_free(pMap);
1718
1719                 evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1720                 evas_object_show(__pImageObject);
1721         }
1722         else
1723         {
1724                 SysSecureLog(NID_UI_CTRL, "not for rotate status operation");
1725
1726                 if (!noImage && __aspectRatio && __pRenderImageObject != null)
1727                 {
1728                         Dimension srcDim(__srcDimension.width, __srcDimension.height);
1729                         SysSecureLog(NID_UI_CTRL, "src dimension is [%d, %d]", srcDim.width, srcDim.height);
1730
1731                         float srcRatio = ((float)srcDim.width) / ((float)srcDim.height);
1732                         float tmpWidth = (float)resizeRectW;
1733                         float tmpHeight = tmpWidth / srcRatio;
1734
1735                         Rectangle lastDst;
1736                         if (resizeRectH < (int)tmpHeight)
1737                         {
1738                                 lastDst.height = resizeRectH;
1739                                 lastDst.width = (int)((float)lastDst.height * srcRatio);
1740                         }
1741                         else
1742                         {
1743                                 lastDst.width = resizeRectW;
1744                                 lastDst.height = (int)((float)lastDst.width / srcRatio);
1745                         }
1746
1747                         lastDst.x = resizeRectX + ((resizeRectW - lastDst.width) / 2);
1748                         lastDst.y = resizeRectY + ((resizeRectH - lastDst.height) / 2);
1749
1750 //                      evas_object_geometry_get(__pImageObject, &orgX, &orgY, &orgW, &orgH);
1751 //                      SysLog(NID_UI_CTRL, "__pImageObject before [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1752
1753                         evas_object_resize(__pImageObject, lastDst.width, lastDst.height);
1754                         evas_object_move(__pImageObject, lastDst.x, lastDst.y);
1755
1756 //                      evas_object_geometry_get(__pImageObject, &orgX, &orgY, &orgW, &orgH);
1757 //                      SysLog(NID_UI_CTRL, "__pImageObject after [%d, %d, %d, %d]", orgX, orgY, orgW, orgH);
1758
1759                         SysSecureLog(NID_UI_CTRL, "Ratio on / lastDst [%d, %d, %d, %d]",lastDst.x, lastDst.y, lastDst.width, lastDst.height);
1760                 }
1761                 else
1762                 {
1763                         evas_object_image_size_get(__pImageObject, &imgWidth, &imgHeight);
1764                         SysSecureLog(NID_UI_CTRL, "image object size is [%d, %d]", imgWidth, imgHeight);
1765
1766                         Evas_Map* pMap = evas_map_new(4);
1767                         evas_map_util_points_populate_from_object(pMap, __pImageObject);
1768
1769                         evas_map_point_coord_set(pMap, 0, resizeRectX, resizeRectY, 0);
1770                         evas_map_point_coord_set(pMap, 1, resizeRectX+resizeRectW, resizeRectY, 0);
1771                         evas_map_point_coord_set(pMap, 2, resizeRectX+resizeRectW, resizeRectY+resizeRectH, 0);
1772                         evas_map_point_coord_set(pMap, 3, resizeRectX, resizeRectY+resizeRectH, 0);
1773
1774                         if(imgWidth > 0 && imgHeight > 0)
1775                         {
1776                                 evas_map_point_image_uv_set(pMap, 0, 0, 0);
1777                                 evas_map_point_image_uv_set(pMap, 1, imgWidth, 0);
1778                                 evas_map_point_image_uv_set(pMap, 2, imgWidth, imgHeight);
1779                                 evas_map_point_image_uv_set(pMap, 3, 0, imgHeight);
1780                         }
1781
1782                         evas_object_map_set(__pImageObject, pMap);
1783                         evas_object_map_enable_set(__pImageObject, EINA_TRUE);
1784                         evas_map_free(pMap);
1785                 }
1786
1787                 evas_object_image_filled_set(__pImageObject, EINA_TRUE);
1788                 evas_object_show(__pImageObject);
1789         }
1790
1791         __pVisualElement->SetFlushNeeded();
1792
1793         return E_SUCCESS;
1794 }
1795
1796 int
1797 _OverlayAgent::GetOverlayAgentCount(void)
1798 {
1799         return __overlayAgentcount;
1800 }
1801
1802 IListT<bool>*
1803 _OverlayAgent::GetPixelFormatListN(void)
1804 {
1805         if (!__OverlayAgentBufferPixelFormat[0])
1806         {
1807                 const wchar_t* _UI_REGISTRY_PATH = L"/usr/etc/system-info.ini";
1808                 const wchar_t* _UI_INFO_SESSION = L"UiControlInfo";
1809
1810                 _RegistryImpl registry;
1811                 result r = registry.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
1812                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1813
1814                 String pixelFormatList(null);
1815                 r = registry.GetValue(_UI_INFO_SESSION, L"OverlayRegionBufferPixelFormat", pixelFormatList);
1816                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1817
1818                 bool set = false;
1819                 if (pixelFormatList.Contains(L"ARGB8888"))
1820                 {
1821                         __OverlayAgentBufferPixelFormat[_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888] = true;
1822                         set = true;
1823                 }
1824
1825                 if (pixelFormatList.Contains(L"RGB565"))
1826                 {
1827                         __OverlayAgentBufferPixelFormat[_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_RGB565] = true;
1828                         set = true;
1829                 }
1830
1831                 if (pixelFormatList.Contains(L"YCbCr420P"))
1832                 {
1833                         __OverlayAgentBufferPixelFormat[_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_YCbCr420_PLANAR] = true;
1834                         set = true;
1835                 }
1836
1837                 if (pixelFormatList.Contains(L"NV12"))
1838                 {
1839                         __OverlayAgentBufferPixelFormat[_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_NV12] = true;
1840                         set = true;
1841                 }
1842
1843                 if (pixelFormatList.Contains(L"UYVY"))
1844                 {
1845                         __OverlayAgentBufferPixelFormat[_OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY] = true;
1846                         set = true;
1847                 }
1848
1849                 SysAssertf(set, "The registry file is an invalid.");
1850
1851                 __OverlayAgentBufferPixelFormat[0] = set;
1852         }
1853
1854         std::unique_ptr< ArrayListT<bool> > pFormatList( new (std::nothrow) ArrayListT<bool>());
1855         SysTryReturn(NID_UI_CTRL, pFormatList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] failed to create a list instance");
1856
1857         result r = pFormatList->Construct();
1858         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1859
1860         for (int index = _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_ARGB8888; index <= _OVERLAY_AGENT_BUFFER_PIXEL_FORMAT_UYVY; index++)
1861         {
1862                 r = pFormatList->Add(__OverlayAgentBufferPixelFormat[index]);
1863         }
1864         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
1865
1866         return pFormatList.release();
1867 }
1868
1869 result
1870 _OverlayAgent::EvaluateBounds(OverlayAgentEvaluationOption option, Rectangle& rect, bool& modified)
1871 {
1872         modified = false;
1873         SysTryReturnResult(NID_UI_CTRL, rect.width > 0 && rect.height > 0, E_INVALID_ARG, "[E_INVALID_ARG] The size of input rectangle(%d, %d) is invalid.", rect.width, rect.height);
1874
1875         int screenWidth = _Screen::GetWidth();
1876         int screenHeight = _Screen::GetHeight();
1877         SysTryReturnResult(NID_UI_CTRL, screenWidth > 0 && screenHeight > 0, E_INVALID_ARG, "[E_SYSTEM] The value of screen size is invalid.");
1878
1879         // if orientation status of screen is landscape mode, swap width and height.
1880         {
1881                 _EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
1882                 int orientation = ecore_evas_rotation_get(pEcoreEvas->GetEcoreEvas());
1883
1884                 if (orientation == 90 || orientation == 270)
1885                 {
1886                         int temp = screenWidth;
1887                         screenWidth = screenHeight;
1888                         screenHeight = temp;
1889                         SysSecureLog(NID_UI_CTRL, "The current value of device screen width is %d, device screen height is %d and orientation is %d", screenWidth, screenHeight, orientation);
1890                 }
1891         }
1892         const int widthUnit = GetWidthUnit();
1893         const int heightUnit = GetHeightUnit();
1894         SysTryReturnResult(NID_UI_CTRL, widthUnit > 0 && heightUnit > 0, E_SYSTEM, "[E_SYSTEM] The value of overlay control's width Unit and height Unit are invalid.");
1895
1896         int physicalMaxWidth= screenWidth - (screenWidth % widthUnit);
1897         int physicalMaxHeight = screenHeight - (screenHeight % heightUnit);
1898         int logicalMaxWidth = _CoordinateSystemUtils::InverseHorizontalTransform(physicalMaxWidth);
1899         int logicalMaxHeight = _CoordinateSystemUtils::InverseVerticalTransform(physicalMaxHeight);
1900         SysSecureLog(NID_UI_CTRL, "The physical Max size of overlay control is (%d, %d) and logical Max size of overlay control is (%d, %d)", physicalMaxWidth, physicalMaxHeight, logicalMaxWidth, logicalMaxHeight);
1901
1902         int dstMinWidth = GetDstRectMinWidth();
1903         int dstMinHeight = GetDstRectMinHeight();
1904         SysTryReturnResult(NID_UI_CTRL, dstMinWidth > 0 && dstMinHeight > 0, E_SYSTEM, "[E_SYSTEM] The value of overlay control's Min width and Min height are invalid.");
1905
1906         Rectangle physicalRect(_CoordinateSystemUtils::Transform(rect));
1907         int widthReminder = physicalRect.width % widthUnit;
1908         int heightReminder = physicalRect.height % heightUnit;
1909
1910         switch (option)
1911         {
1912         case OVERLAY_AGENT_EVALUATION_OPTION_GREATER_THAN:
1913                 {
1914                         if (physicalRect.width > physicalMaxWidth || physicalRect.height > physicalMaxHeight)
1915                         {
1916                                 modified = false;
1917                                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_OPTION, "[E_UNSUPPORTED_OPTION] The size of input rect exceeds physical maximun size.");
1918
1919                                 return E_UNSUPPORTED_OPTION;
1920                         }
1921
1922                         if (rect.width > logicalMaxWidth || rect.height > logicalMaxHeight)
1923                         {
1924                                 modified = false;
1925                                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_OPTION, "[E_UNSUPPORTED_OPTION] The size of input rect exceeds logical maximun size.");
1926
1927                                 return E_UNSUPPORTED_OPTION;
1928                         }
1929
1930                         if (widthReminder != 0)
1931                         {
1932                                 widthReminder -= widthUnit;
1933                         }
1934
1935                         if (heightReminder != 0)
1936                         {
1937                                 heightReminder -= heightUnit;
1938                         }
1939
1940                         physicalRect.width -= widthReminder;
1941                         physicalRect.height -= heightReminder;
1942
1943                         if (physicalRect.width < dstMinWidth)
1944                         {
1945                                 physicalRect.width = dstMinWidth;
1946                         }
1947
1948                         if (physicalRect.height < dstMinHeight)
1949                         {
1950                                 physicalRect.height = dstMinHeight;
1951                         }
1952                 }
1953                 break;
1954         case OVERLAY_AGENT_EVALUATION_OPTION_LESS_THAN:
1955                 {
1956                         if (physicalRect.width < dstMinWidth || physicalRect.height < dstMinHeight)
1957                         {
1958                                 modified = false;
1959                                 SysLogException(NID_UI_CTRL, E_UNSUPPORTED_OPTION, "[E_UNSUPPORTED_OPTION] The size of input rect is under minimun size.");
1960
1961                                 return E_UNSUPPORTED_OPTION;
1962                         }
1963
1964                         if (physicalRect.width > physicalMaxWidth)
1965                         {
1966                                 physicalRect.width = physicalMaxWidth + widthReminder;
1967                         }
1968
1969                         if (physicalRect.height > physicalMaxHeight)
1970                         {
1971                                 physicalRect.height = physicalMaxHeight + heightReminder;
1972                         }
1973
1974                         physicalRect.width -= widthReminder;
1975                         physicalRect.height -= heightReminder;
1976                 }
1977                 break;
1978         default:
1979                 {
1980                         modified = false;
1981                         SysLogException(NID_UI_CTRL, E_UNSUPPORTED_OPTION, "[E_UNSUPPORTED_OPTION] The input option is an invalid.");
1982
1983                         return E_UNSUPPORTED_OPTION;
1984                 }
1985         }
1986
1987         Rectangle originalInputRect(rect);
1988         rect = _CoordinateSystemUtils::InverseTransform(physicalRect);
1989
1990         if (rect != originalInputRect)
1991         {
1992                 SysSecureLog(NID_UI_CTRL, "The rect as a input parameter is adjusted. original rect(%d, %d, %d, %d) is changed to (%d, %d, %d, %d)",
1993                                 originalInputRect.x, originalInputRect.y, originalInputRect.width, originalInputRect.height,
1994                                 rect.x, rect.y, rect.width, rect.height);
1995                 modified = true;
1996         }
1997
1998         SysLog(NID_UI_CTRL, "The current size of valid bounds that is evaluated is (%d, %d, %d, %d)", rect.x, rect.y, rect.width, rect.height);
1999
2000         result r = GetLastResult();
2001         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
2002
2003         return r;
2004 }
2005
2006 int
2007 _OverlayAgent::GetValueFromRegistry(const String& key)
2008 {
2009         const wchar_t* _UI_REGISTRY_PATH = L"/usr/etc/system-info.ini";
2010         const wchar_t* _UI_INFO_SESSION = L"UiControlInfo";
2011
2012         _RegistryImpl registry;
2013         result r = registry.Construct(_UI_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
2014         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, -1, r, "[%s] Propagating.", GetErrorMessage(r));
2015
2016         String strValue(null);
2017         r = registry.GetValue(_UI_INFO_SESSION, key, strValue);
2018         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, -1, r, "[%s] Propagating.", GetErrorMessage(r));
2019
2020         int value;
2021         r = Integer::Parse(strValue, value);
2022         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, -1, r, "[%s] Propagating.", GetErrorMessage(r));
2023
2024         return value;
2025 }
2026
2027 int
2028 _OverlayAgent::GetDstRectMinWidth(void)
2029 {
2030         if (__dstRectMinWidth < 0)
2031         {
2032                 int value = GetValueFromRegistry(L"OverlayDstMinWidth");
2033                 SysTryReturn(NID_UI_CTRL, value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2034
2035                 __dstRectMinWidth = value;
2036         }
2037
2038         SetLastResult(E_SUCCESS);
2039
2040         return __dstRectMinWidth;
2041 }
2042
2043 int
2044 _OverlayAgent::GetDstRectMinHeight(void)
2045 {
2046         if (__dstRectMinHegith < 0)
2047         {
2048                 int value = GetValueFromRegistry(L"OverlayDstMinHeight");
2049                 SysTryReturn(NID_UI_CTRL, value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2050
2051                 __dstRectMinHegith = value;
2052         }
2053
2054         SetLastResult(E_SUCCESS);
2055
2056         return __dstRectMinHegith;
2057 }
2058
2059 int
2060 _OverlayAgent::GetSrcRectMinWidth(void)
2061 {
2062         if (__srcRectMinWidth < 0)
2063         {
2064                 int value = GetValueFromRegistry(L"OverlaySrcMinWidth");
2065                 SysTryReturn(NID_UI_CTRL,  value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2066
2067                 __srcRectMinWidth = value;
2068         }
2069
2070         SetLastResult(E_SUCCESS);
2071
2072         return __srcRectMinWidth;
2073 }
2074
2075 int
2076 _OverlayAgent::GetSrcRectMinHeight(void)
2077 {
2078         if (__srcRectMinHegith < 0)
2079         {
2080                 int value = GetValueFromRegistry(L"OverlaySrcMinHeight");
2081                 SysTryReturn(NID_UI_CTRL,  value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2082
2083                 __srcRectMinHegith = value;
2084         }
2085
2086         SetLastResult(E_SUCCESS);
2087
2088         return __srcRectMinHegith;
2089 }
2090
2091 int
2092 _OverlayAgent::GetWidthUnit(void)
2093 {
2094         if (__overlayWidthUnit < 0)
2095         {
2096                 int value = GetValueFromRegistry(L"OverlayRegionWidthUnit");
2097                 SysTryReturn(NID_UI_CTRL,  value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2098
2099                 __overlayWidthUnit = value;
2100         }
2101
2102         SetLastResult(E_SUCCESS);
2103
2104         return __overlayWidthUnit;
2105 }
2106
2107 int
2108 _OverlayAgent::GetHeightUnit(void)
2109 {
2110         if (__overlayHeightUnit < 0)
2111         {
2112                 int value = GetValueFromRegistry(L"OverlayRegionHeightUnit");
2113                 SysTryReturn(NID_UI_CTRL,  value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2114
2115                 __overlayHeightUnit = value;
2116         }
2117
2118         SetLastResult(E_SUCCESS);
2119
2120         return __overlayHeightUnit;
2121 }
2122
2123 int
2124 _OverlayAgent::GetMaxCount(void)
2125 {
2126         if (__overlayMaxCount < 0)
2127         {
2128                 int value = GetValueFromRegistry(L"MaxOverlayRegionCount");
2129                 SysTryReturn(NID_UI_CTRL,  value > 0, -1, E_SYSTEM, "[E_SYSTEM] Failed to get Overlay info from registry");
2130
2131                 __overlayMaxCount = value;
2132         }
2133
2134         SetLastResult(E_SUCCESS);
2135
2136         return __overlayMaxCount;
2137 }
2138
2139 void
2140 _OverlayAgent::SetEvasImageDirtyCallback(void)
2141 {
2142         if (__pImageObject)
2143         {
2144                 evas_object_image_pixels_get_callback_set(__pImageObject, OnEvasImageDamaged,(void*)this);
2145         }
2146 }
2147
2148 bool
2149 _OverlayAgent::GetEvasImageDirtyFlag(void) const
2150 {
2151         return __evasImageDamaged;
2152 }
2153
2154 void
2155 _OverlayAgent::SetEvasImageDirtyFlag(bool dirty)
2156 {
2157         __evasImageDamaged = dirty;
2158 }
2159
2160 result
2161 _OverlayAgent::MoveChildToTop(const _Control& child)
2162 {
2163         _EflNode* pEflNode = null;
2164         Evas_Object* pSmartObject = null;
2165
2166         _VisualElement* pChildVE = child.GetVisualElement();
2167         SysTryReturn(NID_UI_CTRL, pChildVE != null, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] pChildVE is null.");
2168
2169         pEflNode = dynamic_cast<_EflNode*>(pChildVE->GetNativeNode());
2170         SysTryReturn(NID_UI_CTRL, pEflNode != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pEflNode is null" );
2171
2172         pSmartObject = (Evas_Object*)pEflNode->GetGroupContainer();
2173         SysTryReturn(NID_UI_CTRL, pSmartObject != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] pSmartObject is null" );
2174
2175         evas_object_raise(pSmartObject);
2176
2177         return E_SUCCESS;
2178 }
2179
2180 Dimension
2181 _OverlayAgent::GetPrevCbImageDimension(void) const
2182 {
2183         return __orgCbImgDimension;
2184 }
2185
2186 result
2187 _OverlayAgent::SetPrevCbImageDimension(const Dimension& imgDim)
2188 {
2189         __orgCbImgDimension = imgDim;
2190         return E_SUCCESS;
2191 }
2192
2193 }}} // Tizen::Ui
2194