src/FShell_AppWidgetViewManager.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FShell_AppWidgetViewManager.cpp
  19  * @brief               This is the implementation file for the _AppWidgetView class.
  20  */
  21
  22 #include <new>
  23 #include <Ecore_X.h>
  24 #include <Evas.h>
  25 extern "C"
  26 {
  27 #include <elm_config.h>
  28 }
  29 #include <livebox-service.h>
  30 #include <livebox.h>
  31 #include <FBaseColHashMapT.h>
  32 #include <FBaseSysLog.h>
  33 #include <FBaseString.h>
  34 #include <FGrpBufferInfo.h>
  35 #include <FGrpBitmap.h>
  36 #include <FGrpCanvas.h>
  37 #include <FGrpDimension.h>
  38 #include <FGrpPixelFormat.h>
  39 #include <FGrpPoint.h>
  40 #include <FGrpRectangle.h>
  41 #include <FMediaImageTypes.h>
  42 #include <FBase_StringConverter.h>
  43 #include <FGrp_BitmapImpl.h>
  44 #include <FGrp_CoordinateSystem.h>
  45 #include <FMedia_ImageDecoder.h>
  46 #include <FUi_ControlManager.h>
  47 #include <FUiCtrl_Frame.h>
  48 #include <FUiCtrl_IFrameEventListener.h>
  49 #include "FShell_AppWidgetViewManager.h"
  50 #include "FShell_AppWidgetView.h"
  51 #include "FShell_AppWidgetPopupView.h"
  52
  53 //#define _PIXMAP_TEST
  54
  55 #if defined(_PIXMAP_TEST)
  56 extern "C"
  57 {
  58 #include <stdio.h>
  59 #include <stdlib.h>
  60 #include <X11/Xproto.h>
  61 #include <fcntl.h>
  62 #include <unistd.h>
  63 #include <dri2.h>
  64 #define virtual UICTRL_INTERNAL_VIRTUAL_REDEFINE
  65 #define private UICTRL_INTERNAL_PRIVATE_REDEFINE
  66 #include <libdrm/drm_slp_bufmgr.h>
  67 #undef virtual
  68 #undef private
  69 }
  70 #endif // _PIXMAP_TEST
  71
  72 using namespace std;
  73 using namespace Tizen::Base;
  74 using namespace Tizen::Base::Collection;
  75 using namespace Tizen::Graphics;
  76 using namespace Tizen::Media;
  77 using namespace Tizen::Ui;
  78 using namespace Tizen::Ui::Controls;
  79
  80 namespace
  81 {
  82
  83 #if defined(_PIXMAP_TEST)
  84
  85 drm_slp_bufmgr __bufMgr = null;
  86 int __FileCount = 0;
  87
  88 void
  89 dump_bmp(const char* pFileName, const void* pData, int width, int height)
  90 {
  91         int i = 0;
  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         unsigned int* pBlocks = null;
 122
 123         FILE* pFile = fopen(pFileName, "w+");
 124         if (pFile == null)
 125         {
 126                 SysLog(NID_UI_CTRL, "failed to fopen [%s]", pFileName);
 127                 return;
 128         }
 129         else
 130         {
 131                 bmpfile_header.filesz = sizeof(bmpfile_magic) + sizeof(bmpfile_header) + sizeof(bmp_dib_v3_header_t) + width * height * 3;
 132                 bmp_dib_v3_header_t.header_sz = sizeof(bmp_dib_v3_header_t);
 133                 bmp_dib_v3_header_t.width = width;
 134                 bmp_dib_v3_header_t.height = -height;
 135                 bmp_dib_v3_header_t.nplanes = 1;
 136                 bmp_dib_v3_header_t.bmp_bytesz = width * height * 3;
 137
 138                 fwrite(&bmpfile_magic, sizeof(bmpfile_magic), 1, pFile);
 139                 fwrite(&bmpfile_header, sizeof(bmpfile_header), 1, pFile);
 140                 fwrite(&bmp_dib_v3_header_t, sizeof(bmp_dib_v3_header_t), 1, pFile);
 141
 142                 pBlocks = (unsigned int*)pData;
 143                 for (i = 0; i < (height * width); i++)
 144                         fwrite(&pBlocks[i], 3, 1, pFile);
 145
 146                 fclose(pFile);
 147         }
 148
 149         return;
 150 }
 151
 152 drm_slp_bufmgr
 153 bufmgr_get(Display* pDisplay, Pixmap pixmap)
 154 {
 155         int screen;
 156         int drm_fd;
 157         drm_slp_bufmgr bufmgr;
 158         int eventBase, errorBase;
 159         int dri2Major, dri2Minor;
 160         char* pDriverName, *pDeviceName;
 161         drm_magic_t magic;
 162
 163         screen = DefaultScreen(pDisplay);
 164
 165         /* DRI2 */
 166         if (!DRI2QueryExtension (pDisplay, &eventBase, &errorBase))
 167         {
 168                 SysLog(NID_UI_CTRL, "!!Error : DRI2QueryExtension !!\n");
 169                 return null;
 170         }
 171
 172         if (!DRI2QueryVersion (pDisplay, &dri2Major, &dri2Minor))
 173         {
 174                 SysLog(NID_UI_CTRL, "!!Error : DRI2QueryVersion !!\n");
 175                 return null;
 176         }
 177
 178         if (!DRI2Connect (pDisplay, RootWindow(pDisplay, screen), &pDriverName, &pDeviceName))
 179         {
 180                 SysLog(NID_UI_CTRL, "!!Error : DRI2Connect !!\n");
 181                 return null;
 182         }
 183
 184         SysLog(NID_UI_CTRL, "Open drm device : %s\n", pDeviceName);
 185
 186         /* get the drm_fd though opening the deviceName */
 187         drm_fd = open (pDeviceName, O_RDWR);
 188         if (drm_fd < 0)
 189         {
 190                 SysLog(NID_UI_CTRL, "!!Error : cannot open drm device (%s)\n", pDeviceName);
 191                 return null;
 192         }
 193
 194         /* get the drm magic */
 195         drmGetMagic(drm_fd, &magic);
 196         printf("drm magic = %d \n", magic);
 197
 198         if (!DRI2Authenticate(pDisplay, RootWindow(pDisplay, screen), magic))
 199         {
 200                 SysLog(NID_UI_CTRL, "!!Error : DRI2Authenticate !!\n");
 201                 close (drm_fd);
 202                 return null;
 203         }
 204
 205         /* drm slp buffer manager init */
 206         bufmgr = drm_slp_bufmgr_init (drm_fd, null);
 207         if (!bufmgr)
 208         {
 209                 SysLog(NID_UI_CTRL, "!!Error : failed to init buffer manager \n");
 210                 close (drm_fd);
 211                 return null;
 212         }
 213
 214         DRI2CreateDrawable (pDisplay, pixmap);
 215
 216         return bufmgr;
 217 }
 218
 219 void
 220 pixmap_update(Display* pDisplay, drm_slp_bufmgr bufmgr, Pixmap pixmap, int x, int y, int width, int height)
 221 {
 222         DRI2Buffer* pDri2_buffers = null;
 223         unsigned int attachments[1];
 224         int dri2_count, dri2_out_count;
 225         int dri2_width, dri2_height, dri2_stride;
 226         drm_slp_bo bo;
 227         int opt;
 228         void* pVirtualBuf = null;
 229         char imgFile[100] = {0,};
 230
 231         attachments[0] = DRI2BufferFrontLeft;
 232         dri2_count = 1;
 233         pDri2_buffers = DRI2GetBuffers (pDisplay, pixmap, &dri2_width, &dri2_height,
 234                 attachments, dri2_count, &dri2_out_count);
 235
 236         if (!pDri2_buffers)
 237         {
 238                 SysLog(NID_UI_CTRL, "[Error] : failed to get buffers\n");
 239                 goto update_done;
 240         }
 241
 242         if (!pDri2_buffers[0].name)
 243         {
 244                 SysLog(NID_UI_CTRL, "[Error] : a handle of the dri2 buffer is null \n ");
 245                 goto update_done;
 246         }
 247
 248         SysLog(NID_UI_CTRL, "pDri2_buffers[0].name : %d", pDri2_buffers[0].name);
 249
 250         bo = drm_slp_bo_import(bufmgr, pDri2_buffers[0].name);
 251         if (!bo)
 252         {
 253                 SysLog(NID_UI_CTRL, "[Error] : cannot import bo (key:%d)\n", pDri2_buffers[0].name);
 254                 goto update_done;
 255         }
 256
 257         dri2_stride = pDri2_buffers[0].pitch;
 258
 259         opt = DRM_SLP_OPTION_READ|DRM_SLP_OPTION_WRITE;
 260         pVirtualBuf = (void*)drm_slp_bo_map (bo, DRM_SLP_DEVICE_CPU, opt);
 261         if (!pVirtualBuf)
 262         {
 263                 SysLog(NID_UI_CTRL, "[Error] : failed to map \n");
 264                 goto update_done;
 265         }
 266
 267         memset(imgFile, 0, sizeof(imgFile));
 268         sprintf(imgFile,"./dump%d.bmp", __FileCount++);
 269         dump_bmp(imgFile, pVirtualBuf, dri2_width, dri2_height);
 270
 271 update_done:
 272         if (pVirtualBuf)
 273                 drm_slp_bo_unmap(bo, DRM_SLP_DEVICE_CPU);
 274         if (bo)
 275                 drm_slp_bo_unref(bo);
 276         if (pDri2_buffers)
 277                 free(pDri2_buffers);
 278 }
 279
 280 void
 281 DumpPixmap(int pixmap)
 282 {
 283         int x = 0;
 284         int y = 0;
 285         int width = 0;
 286         int height = 0;
 287
 288         ecore_x_pixmap_geometry_get(pixmap, &x, &y, &width, &height);
 289         SysTryReturnVoidResult(NID_UI_CTRL, (width > 0) && (height > 0), E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid [0x%x %d %d].", pixmap, width , height);
 290
 291         if (__bufMgr)
 292         {
 293                 drm_slp_bufmgr_destroy(__bufMgr);
 294                 __bufMgr = null;
 295         }
 296
 297         if (__bufMgr == null)
 298                 __bufMgr = bufmgr_get((Display*)ecore_x_display_get(), pixmap);
 299
 300         if (__bufMgr != null)
 301         {
 302                 pixmap_update((Display*)ecore_x_display_get(), __bufMgr, pixmap, 0, 0, width, height);
 303         }
 304         else
 305                 SysLog(NID_UI_CTRL, "can't get pixmap __bufMgr");
 306
 307         SysLog(NID_UI_CTRL, "dump pixmap [%d]", pixmap);
 308 }
 309
 310 #endif // _PIXMAP_TEST
 311
 312 }
 313
 314 namespace Tizen { namespace Graphics
 315 {
 316 result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*&, _LogicalResolution, _BaseScreenSize, _PhysicalResolution, _BaseScreenSize);
 317 } } // Tizen::Graphics
 318
 319 namespace Tizen { namespace Shell
 320 {
 321
 322 const int LIVEBOX_SIZE_1 = 175;
 323 const int LIVEBOX_SIZE_2 = 354;
 324 const int LIVEBOX_SIZE_4 = 712;
 325
 326 struct _AppWidgetSizeInfo
 327 {
 328         int type;
 329         int width;
 330         int height;
 331 };
 332
 333 const _AppWidgetSizeInfo LIVEBOX_SIZE_INFO[] =
 334 {
 335         { LB_SIZE_TYPE_1x1, LIVEBOX_SIZE_1, LIVEBOX_SIZE_1 },
 336         { LB_SIZE_TYPE_2x1, LIVEBOX_SIZE_2, LIVEBOX_SIZE_1 },
 337         { LB_SIZE_TYPE_2x2, LIVEBOX_SIZE_2, LIVEBOX_SIZE_2 },
 338         { LB_SIZE_TYPE_4x1, LIVEBOX_SIZE_4, LIVEBOX_SIZE_1 },
 339         { LB_SIZE_TYPE_4x2, LIVEBOX_SIZE_4, LIVEBOX_SIZE_2 },
 340         { LB_SIZE_TYPE_4x4, LIVEBOX_SIZE_4, LIVEBOX_SIZE_4 }
 341
 342 };
 343
 344 _AppWidgetViewManager*
 345 _AppWidgetViewManager::GetInstance(void)
 346 {
 347         static _AppWidgetViewManager instance;
 348         return &instance;
 349 }
 350
 351 livebox*
 352 _AppWidgetViewManager::AddAppWidgetView(_AppWidgetView* pAppWidgetView, const String& userInfo)
 353 {
 354         SysTryReturn(NID_UI_CTRL, pAppWidgetView, null, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 355
 356         unique_ptr<char[]> pAppWidgetId(_StringConverter::CopyToCharArrayN(pAppWidgetView->GetAppWidgetId()));
 357         SysTryReturn(NID_UI_CTRL, pAppWidgetId, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 358
 359         unique_ptr<char[]> pContent(_StringConverter::CopyToCharArrayN(userInfo));
 360         SysTryReturn(NID_UI_CTRL, pContent, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 361
 362         const char* pCluster = "user,created";
 363         const char* pCategory = "default";
 364         double period = 1.0f;
 365         int sizeType = GetAppWidgetSizeType(pAppWidgetView->GetSizeF());
 366
 367         livebox* pAppWidget = livebox_add_with_size(pAppWidgetId.get(), pContent.get(), pCluster, pCategory, period, sizeType, OnAppWidgetAdded, this);
 368         SysTryReturn(NID_UI_CTRL, pAppWidget, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 369
 370         __pViewMap->Add(pAppWidget, pAppWidgetView);
 371
 372         return pAppWidget;
 373 }
 374
 375 void
 376 _AppWidgetViewManager::RemoveAppWidgetView(_AppWidgetView* pAppWidgetView)
 377 {
 378         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetView, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 379
 380         livebox* pAppWidget = pAppWidgetView->GetNativeAppWidget();
 381         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 382
 383         __pViewMap->Remove(pAppWidget);
 384
 385         livebox_del(pAppWidget, OnAppWidgetDeleted, this);
 386
 387         __pViewMap->Remove(pAppWidget);
 388 }
 389
 390 _AppWidgetView*
 391 _AppWidgetViewManager::GetAppWidgetView(livebox* pAppWidget) const
 392 {
 393         _AppWidgetView* pAppWidgetView = null;
 394         __pViewMap->GetValue(pAppWidget, pAppWidgetView);
 395
 396         return pAppWidgetView;
 397 }
 398
 399 FloatDimension
 400 _AppWidgetViewManager::GetAppWidgetSize(livebox* pAppWidget) const
 401 {
 402         SysTryReturn(NID_UI_CTRL, pAppWidget, FloatDimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 403
 404         int width = 0;
 405         int height = 0;
 406
 407         int type = livebox_size(pAppWidget);
 408         livebox_service_get_size(type, &width, &height);
 409
 410 //      SysLog(NID_UI_CTRL, "size [%d %d]", width, height);
 411
 412         return FloatDimension(width, height);
 413 }
 414
 415 FloatDimension
 416 _AppWidgetViewManager::GetAppWidgetPopupSize(livebox* pAppWidget) const
 417 {
 418         SysTryReturn(NID_UI_CTRL, pAppWidget, FloatDimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 419
 420         int width = 0;
 421         int height = 0;
 422
 423         livebox_get_pdsize(pAppWidget, &width, &height);
 424
 425 //      SysLog(NID_UI_CTRL, "size [%d %d]", width, height);
 426
 427         return FloatDimension(width, height);
 428 }
 429
 430 void
 431 _AppWidgetViewManager::SetAppWidgetSize(const _AppWidgetView& appwidgetView, const FloatDimension& size)
 432 {
 433         livebox* pAppWidget = appwidgetView.GetNativeAppWidget();
 434         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 435
 436         int sizeType = GetAppWidgetSizeType(size);
 437
 438         livebox_resize(pAppWidget, sizeType, OnAppWidgetResized, this);
 439 }
 440
 441 void
 442 _AppWidgetViewManager::AddFrameEventListener(void)
 443 {
 444         if (!__pFrameEventListener)
 445         {
 446                 unique_ptr<_FrameEventListener> pFrameEventListener(new (std::nothrow) _FrameEventListener());
 447                 SysTryReturnVoidResult(NID_UI_CTRL, pFrameEventListener, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 448
 449                 _Window* pWindow = _ControlManager::GetInstance()->GetCurrentFrame();
 450                 SysTryReturnVoidResult(NID_UI_CTRL, pWindow, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 451
 452                 __pFrameEventListener = move(pFrameEventListener);
 453
 454                 _Frame* pFrame = dynamic_cast<_Frame*>(pWindow);
 455                 if (pFrame)
 456                 {
 457                         pFrame->AddFrameEventListener(*__pFrameEventListener);
 458                 }
 459         }
 460 }
 461
 462 _AppWidgetViewManager::_AppWidgetViewManager(void)
 463         : __glMode(false)
 464 {
 465 //      _LogicalResolution sourceResolution = RESOLUTION_LOGICAL_720;
 466 //      _PhysicalResolution destResolution = _CoordinateSystem::GetInstance()->GetPhysicalResolution();
 467
 468         livebox_init(ecore_x_display_get());
 469         livebox_subscribe_group("*", "*");
 470
 471         __eventHandler.reset(livebox_set_event_handler(OnAppWidgetEventReceived, this));
 472         SysTryReturnVoidResult(NID_UI_CTRL, __eventHandler == 0, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 473
 474         __faultEventHandler.reset(livebox_set_fault_handler(OnAppWidgetFaultReceived, this));
 475         SysTryReturnVoidResult(NID_UI_CTRL, __faultEventHandler == 0, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 476
 477         unique_ptr<HashMapT<livebox*, _AppWidgetView*> > pViewMap(new (std::nothrow) HashMapT<livebox*, _AppWidgetView*>);
 478         SysTryReturnVoidResult(NID_UI_CTRL, pViewMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 479
 480         result r = pViewMap->Construct();
 481         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 482
 483         __pViewMap = move(pViewMap);
 484         __glMode = IsGlMode();
 485
 486 //      r = _CreateCoordinateTransformer(__pCoordinateTransformer, sourceResolution, BASE_SCREEN_SIZE_NORMAL, destResolution, BASE_SCREEN_SIZE_NORMAL);
 487 //      SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 488 }
 489
 490 _AppWidgetViewManager::~_AppWidgetViewManager(void)
 491 {
 492         _ControlManager* pControlManager = _ControlManager::GetInstance();
 493         if (pControlManager && __pFrameEventListener)
 494         {
 495                 _Window* pWindow = pControlManager->GetCurrentFrame();
 496                 if (pWindow)
 497                 {
 498                         _Frame* pFrame = dynamic_cast<_Frame*>(pWindow);
 499                         if (pFrame)
 500                         {
 501                                 pFrame->RemoveFrameEventListener(*__pFrameEventListener);
 502                         }
 503                 }
 504         }
 505 }
 506
 507 int
 508 _AppWidgetViewManager::GetAppWidgetSizeType(const Tizen::Graphics::FloatDimension& size) const
 509 {
 510         int sizeType = LB_SIZE_TYPE_UNKNOWN;
 511
 512         int sizetypeCount = sizeof(LIVEBOX_SIZE_INFO) / sizeof(_AppWidgetSizeInfo);
 513         for ( int i = 0; i < sizetypeCount; ++ i)
 514         {
 515                 if (size.width <= LIVEBOX_SIZE_INFO[i].width && size.height <= LIVEBOX_SIZE_INFO[i].height)
 516                 {
 517                         sizeType = LIVEBOX_SIZE_INFO[i].type;
 518                         break;
 519                 }
 520         }
 521
 522         SysLog(NID_UI_CTRL, "[%d %d] type [%d][%d]", size.width, size.height, sizeType, sizetypeCount);
 523
 524         return sizeType;
 525 }
 526
 527 MediaPixelFormat
 528 _AppWidgetViewManager::GetPixelFormat(BitmapPixelFormat format) const
 529 {
 530         MediaPixelFormat mediaPixelFormat = MEDIA_PIXEL_FORMAT_NONE;
 531
 532         switch(format)
 533         {
 534         case BITMAP_PIXEL_FORMAT_RGB565:
 535                 mediaPixelFormat = MEDIA_PIXEL_FORMAT_RGB565LE;
 536                 break;
 537
 538         case BITMAP_PIXEL_FORMAT_ARGB8888:
 539                 mediaPixelFormat = MEDIA_PIXEL_FORMAT_BGRA8888;
 540                 break;
 541
 542         case BITMAP_PIXEL_FORMAT_R8G8B8A8:
 543                 mediaPixelFormat = MEDIA_PIXEL_FORMAT_RGBA8888;
 544                 break;
 545
 546         default:
 547                 break;
 548         }
 549
 550         return mediaPixelFormat;
 551 }
 552
 553 Bitmap*
 554 _AppWidgetViewManager::GetBitmapN(const String& fileName) const
 555 {
 556         int width = 0;
 557         int height = 0;
 558
 559         MediaPixelFormat format = GetPixelFormat(BITMAP_PIXEL_FORMAT_ARGB8888);
 560
 561         unique_ptr<ByteBuffer> pByteBuffer(_ImageDecoder::DecodeToBufferN(fileName, format, width, height));
 562         SysTryReturn(NID_UI_CTRL, pByteBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 563
 564         unique_ptr<Bitmap> pBitmap(_BitmapImpl::GetNonScaledBitmapN(*pByteBuffer, Dimension(width, height), BITMAP_PIXEL_FORMAT_ARGB8888));
 565         SysTryReturn(NID_UI_CTRL, pBitmap, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 566
 567         return pBitmap.release();
 568 }
 569
 570 Bitmap*
 571 _AppWidgetViewManager::GetBitmapN(void* pBuffer, const FloatDimension& size) const
 572 {
 573         SysTryReturn(NID_UI_CTRL, pBuffer, null, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 574
 575         byte* pTempBuffer = static_cast<byte*>(pBuffer);
 576         const int BITS_PER_PIXEL = 32;
 577         int length = size.width * size.height * BITS_PER_PIXEL / 8;
 578
 579         unique_ptr<ByteBuffer> pByteBuffer(new (std::nothrow) ByteBuffer());
 580         SysTryReturn(NID_UI_CTRL, pByteBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 581
 582         result r = pByteBuffer->Construct(pTempBuffer, 0, length, length);
 583         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 584
 585         unique_ptr<Bitmap> pBitmap(_BitmapImpl::GetNonScaledBitmapN(*pByteBuffer.get(), Dimension(size.width, size.height), BITMAP_PIXEL_FORMAT_ARGB8888));
 586         SysTryReturn(NID_UI_CTRL, pBitmap, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 587
 588         return pBitmap.release();
 589 }
 590
 591 bool
 592 _AppWidgetViewManager::IsGlMode(void) const
 593 {
 594         int mode = 0;
 595         bool glMode = false;
 596         String preferred(elm_config_preferred_engine_get());
 597         if(preferred == L"opengl_x11")
 598         {
 599                 glMode = true;
 600                 mode = 1;
 601         }
 602         else if(preferred == L"software_x11")
 603         {
 604                 glMode = false;
 605                 mode = 2;
 606         }
 607         else
 608         {
 609                 String engineConfig(elm_config_engine_get());
 610                 if(engineConfig == L"opengl_x11")
 611                 {
 612                         glMode = true;
 613                         mode = 3;
 614                 }
 615         }
 616
 617         SysLog(NID_UI_CTRL, "[%d %d]", mode, glMode);
 618
 619         return glMode;
 620 }
 621
 622 void
 623 _AppWidgetViewManager::OnAppWidgetCreated(livebox* pAppWidget)
 624 {
 625 }
 626
 627 void
 628 _AppWidgetViewManager::OnAppWidgetUpdated(livebox* pAppWidget)
 629 {
 630         _AppWidgetView* pAppWidgetView = GetAppWidgetView(pAppWidget);
 631         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 632
 633         int type = livebox_lb_type(pAppWidget);
 634
 635 //      SysLog(NID_UI_CTRL, "type (%d)", type);
 636
 637         switch (type)
 638         {
 639         case LB_TYPE_IMAGE:
 640                 {
 641                         unique_ptr<Bitmap> pBitmap(GetBitmapN(livebox_filename(pAppWidget)));
 642                         SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 643
 644                         pAppWidgetView->OnAppWidgetUpdated(*pBitmap.get(), GetAppWidgetSize(pAppWidget));
 645                         pBitmap.release();
 646                 }
 647                 break;
 648
 649         case LB_TYPE_BUFFER:
 650                 {
 651                         void* pBuffer = livebox_acquire_fb(pAppWidget);
 652                         SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 653
 654                         FloatDimension sourceSize = GetAppWidgetSize(pAppWidget);
 655                         SysLog(NID_UI_CTRL, "size [%d %d]", sourceSize.width, sourceSize.height);
 656
 657                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 658                         SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 659
 660                         pAppWidgetView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 661                         livebox_release_fb(pBuffer);
 662                         pBitmap.release();
 663                 }
 664                 break;
 665
 666         case LB_TYPE_PIXMAP:
 667                 if (__glMode)
 668                 {
 669                         pAppWidgetView->OnAppWidgetUpdated(livebox_lb_pixmap(pAppWidget));
 670
 671 #if defined(_PIXMAP_TEST)
 672                         DumpPixmap(livebox_lb_pixmap(pAppWidget));
 673 #endif // _PIXMAP_TEST
 674                 }
 675                 else
 676                 {
 677                         void* pBuffer = livebox_acquire_fb(pAppWidget);
 678                         SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 679
 680                         FloatDimension sourceSize = GetAppWidgetSize(pAppWidget);
 681
 682                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 683                         SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 684
 685                         pAppWidgetView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 686                         livebox_release_fb(pBuffer);
 687                         pBitmap.release();
 688                 }
 689                 break;
 690
 691         default:
 692                 break;
 693         }
 694 }
 695
 696 void
 697 _AppWidgetViewManager::OnAppWidgetDeleted(livebox* pAppWidget)
 698 {
 699         _AppWidgetView* pAppWidgetView = GetAppWidgetView(pAppWidget);
 700         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 701
 702         pAppWidgetView->CallProviderRemoved();
 703 }
 704
 705 void
 706 _AppWidgetViewManager::OnAppWidgetPinUpChanged(livebox* pAppWidget)
 707 {
 708 }
 709
 710 void
 711 _AppWidgetViewManager::OnAppWidgetPopupUpdated(livebox* pAppWidget)
 712 {
 713         _AppWidgetView* pAppWidgetView = GetAppWidgetView(pAppWidget);
 714         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 715
 716         _AppWidgetPopupView* pAppWidgetPopupView = pAppWidgetView->GetAppWidgetPopup();
 717         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetPopupView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 718
 719         int type = livebox_pd_type(pAppWidget);
 720
 721 //      SysLog(NID_UI_CTRL, "type (%d)", type);
 722
 723         switch (type)
 724         {
 725         case PD_TYPE_BUFFER:
 726                 {
 727                         void* pBuffer = livebox_acquire_pdfb(pAppWidget);
 728                         SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 729
 730                         FloatDimension sourceSize = GetAppWidgetPopupSize(pAppWidget);
 731
 732                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 733                         SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 734
 735                         pAppWidgetPopupView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 736                         livebox_release_pdfb(pBuffer);
 737                         pBitmap.release();
 738                 }
 739                 break;
 740
 741         case PD_TYPE_PIXMAP:
 742                 if (__glMode)
 743                 {
 744                         pAppWidgetPopupView->OnAppWidgetUpdated(livebox_pd_pixmap(pAppWidget));
 745 #if defined(_PIXMAP_TEST)
 746                         DumpPixmap(livebox_pd_pixmap(pAppWidget));
 747 #endif // _PIXMAP_TEST
 748                 }
 749                 else
 750                 {
 751                         void* pBuffer = livebox_acquire_pdfb(pAppWidget);
 752                         SysTryReturnVoidResult(NID_UI_CTRL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 753
 754                         FloatDimension sourceSize = GetAppWidgetPopupSize(pAppWidget);
 755
 756                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 757                         SysTryReturnVoidResult(NID_UI_CTRL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 758
 759                         pAppWidgetPopupView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 760                         livebox_release_pdfb(pBuffer);
 761                         pBitmap.release();
 762                 }
 763                 break;
 764
 765         default:
 766                 break;
 767         }
 768 }
 769
 770 int
 771 _AppWidgetViewManager::OnAppWidgetEventReceived(livebox* pAppWidget, livebox_event_type eventType, void* pData)
 772 {
 773         SysTryReturn(NID_UI_CTRL, pAppWidget, EXIT_SUCCESS, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 774
 775         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 776         SysTryReturn(NID_UI_CTRL, pAppWidgetViewManager, EXIT_SUCCESS, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 777
 778         switch (eventType)
 779         {
 780         case LB_EVENT_LB_UPDATED:
 781                 pAppWidgetViewManager->OnAppWidgetUpdated(pAppWidget);
 782                 break;
 783
 784         case LB_EVENT_PD_UPDATED:
 785                 pAppWidgetViewManager->OnAppWidgetPopupUpdated(pAppWidget);
 786                 break;
 787
 788         case LB_EVENT_CREATED:
 789                 pAppWidgetViewManager->OnAppWidgetCreated(pAppWidget);
 790                 break;
 791
 792         case LB_EVENT_DELETED:
 793                 pAppWidgetViewManager->OnAppWidgetDeleted(pAppWidget);
 794                 break;
 795
 796         case LB_EVENT_GROUP_CHANGED:
 797                 break;
 798
 799         case LB_EVENT_PINUP_CHANGED:
 800                 pAppWidgetViewManager->OnAppWidgetPinUpChanged(pAppWidget);
 801                 break;
 802
 803         case LB_EVENT_PERIOD_CHANGED:
 804                 break;
 805
 806         default:
 807                 SysLog(NID_UI_CTRL, "Not supported event type: %d", eventType);
 808                 break;
 809         }
 810
 811         return EXIT_SUCCESS;
 812 }
 813
 814 int
 815 _AppWidgetViewManager::OnAppWidgetFaultReceived(livebox_fault_type faultType, const char* pAppWidgetId, const char* pFilename, const char* pFuncName, void* pData)
 816 {
 817         if (faultType == LB_FAULT_DEACTIVATED)
 818         {
 819                 SysLog(NID_UI_CTRL, "type (%d) packageName (%s) fileName (%s) funcName (%s)", faultType, pAppWidgetId, pFilename, pFuncName);
 820                 livebox_activate(pAppWidgetId, OnAppWidgetActivated, pData);
 821         }
 822
 823         return EXIT_SUCCESS;
 824 }
 825
 826 void
 827 _AppWidgetViewManager::OnAppWidgetActivated(livebox* pAppWidget, int ret, void* pData)
 828 {
 829         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 830         SysTryReturnVoidResult(NID_UI_CTRL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 831
 832         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 833         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 834 }
 835
 836 void
 837 _AppWidgetViewManager::OnAppWidgetAdded(livebox* pAppWidget, int ret, void* pData)
 838 {
 839         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 840         SysTryReturnVoidResult(NID_UI_CTRL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 841
 842         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 843         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 844 }
 845
 846 void
 847 _AppWidgetViewManager::OnAppWidgetDeleted(livebox* pAppWidget, int ret, void* pData)
 848 {
 849         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 850         SysTryReturnVoidResult(NID_UI_CTRL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 851
 852         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 853         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 854 }
 855
 856 void
 857 _AppWidgetViewManager::OnAppWidgetResized(livebox* pAppWidget, int ret, void* pData)
 858 {
 859         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 860         SysTryReturnVoidResult(NID_UI_CTRL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 861
 862         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 863         SysTryReturnVoidResult(NID_UI_CTRL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 864
 865         pAppWidgetViewManager->OnAppWidgetUpdated(pAppWidget);
 866 }
 867
 868 void
 869 _AppWidgetViewManager::_FrameEventListener::OnFrameActivated(const Tizen::Ui::Controls::_Frame& source)
 870 {
 871         int ret = livebox_client_resumed();
 872         SysLog(NID_UI_CTRL, "ret (%d)", ret);
 873 }
 874
 875 void
 876 _AppWidgetViewManager::_FrameEventListener::OnFrameDeactivated(const Tizen::Ui::Controls::_Frame& source)
 877 {
 878         int ret = livebox_client_paused();
 879         SysLog(NID_UI_CTRL, "ret (%d)", ret);
 880 }
 881
 882 void
 883 _AppWidgetViewManager::_FrameEventListener::OnFrameMinimized(const Tizen::Ui::Controls::_Frame& source)
 884 {
 885 }
 886
 887 void
 888 _AppWidgetViewManager::_FrameEventListener::OnFrameRestored(const Tizen::Ui::Controls::_Frame& source)
 889 {
 890 }
 891
 892 }} // Tizen::Shell