src/FShell_AppWidgetViewManager.cpp

   1 //
   2 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16 /**
  17  * @file                FShell_AppWidgetViewManager.cpp
  18  * @brief               This is the implementation file for the _AppWidgetView class.
  19  */
  20
  21 #include <new>
  22 #include <Evas.h>
  23 #include <Ecore.h>
  24 extern "C"
  25 {
  26 #include <elm_config.h>
  27 }
  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_AppWidgetBuffer.h"
  50 #include "FShell_AppWidgetViewManager.h"
  51 #include "FShell_AppWidgetView.h"
  52 #include "FShell_AppWidgetPopupView.h"
  53
  54 //#define _DUMP_BUFFER
  55
  56 using namespace std;
  57 using namespace Tizen::Base;
  58 using namespace Tizen::Base::Collection;
  59 using namespace Tizen::Graphics;
  60 using namespace Tizen::Media;
  61 using namespace Tizen::Ui;
  62 using namespace Tizen::Ui::Controls;
  63
  64 namespace Tizen { namespace Graphics
  65 {
  66 //result _CreateCoordinateTransformer(_ICoordinateSystemTransformer*&, _LogicalResolution, _BaseScreenSize, _PhysicalResolution, _BaseScreenSize);
  67 } } // Tizen::Graphics
  68
  69 namespace Tizen { namespace Shell
  70 {
  71
  72 const int LIVEBOX_SIZE_1 = 175;
  73 const int LIVEBOX_SIZE_2 = 354;
  74 const int LIVEBOX_SIZE_4 = 712;
  75 const int LIVEBOX_SIZE_5 = 891;
  76 const int LIVEBOX_SIZE_6 = 1070;
  77
  78 struct _AppWidgetSizeInfo
  79 {
  80         int type;
  81         int width;
  82         int height;
  83 };
  84
  85 const _AppWidgetSizeInfo LIVEBOX_SIZE_INFO[] =
  86 {
  87         { LB_SIZE_TYPE_1x1, LIVEBOX_SIZE_1, LIVEBOX_SIZE_1 },
  88         { LB_SIZE_TYPE_2x1, LIVEBOX_SIZE_2, LIVEBOX_SIZE_1 },
  89         { LB_SIZE_TYPE_2x2, LIVEBOX_SIZE_2, LIVEBOX_SIZE_2 },
  90         { LB_SIZE_TYPE_4x1, LIVEBOX_SIZE_4, LIVEBOX_SIZE_1 },
  91         { LB_SIZE_TYPE_4x2, LIVEBOX_SIZE_4, LIVEBOX_SIZE_2 },
  92         { LB_SIZE_TYPE_4x4, LIVEBOX_SIZE_4, LIVEBOX_SIZE_4 },
  93         { LB_SIZE_TYPE_4x5, LIVEBOX_SIZE_4, LIVEBOX_SIZE_5 },
  94         { LB_SIZE_TYPE_4x6, LIVEBOX_SIZE_4, LIVEBOX_SIZE_6 }
  95
  96 };
  97
  98 _AppWidgetViewManager*
  99 _AppWidgetViewManager::GetInstance(void)
 100 {
 101         static _AppWidgetViewManager instance;
 102         return &instance;
 103 }
 104
 105 livebox*
 106 _AppWidgetViewManager::AddAppWidgetView(_AppWidgetView* pAppWidgetView, const String& userInfo)
 107 {
 108         SysTryReturn(NID_SHELL, pAppWidgetView, null, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 109
 110         unique_ptr<char[]> pAppWidgetId(_StringConverter::CopyToCharArrayN(pAppWidgetView->GetAppWidgetId()));
 111         SysTryReturn(NID_SHELL, pAppWidgetId, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 112
 113         unique_ptr<char[]> pContent(_StringConverter::CopyToCharArrayN(userInfo));
 114         SysTryReturn(NID_SHELL, pContent, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 115
 116         const char* pCluster = "user,created";
 117         const char* pCategory = "default";
 118         double period = 1.0f;
 119         int sizeType = GetAppWidgetSizeType(pAppWidgetView->GetSizeF());
 120
 121         livebox* pAppWidget = livebox_add_with_size(pAppWidgetId.get(), pContent.get(), pCluster, pCategory, period, sizeType, OnAppWidgetAdded, this);
 122         SysTryReturn(NID_SHELL, pAppWidget, null, E_OBJ_NOT_FOUND, "[%s] Propagating.", GetErrorMessage(E_OBJ_NOT_FOUND));
 123
 124         __pViewMap->Add(pAppWidget, pAppWidgetView);
 125
 126         return pAppWidget;
 127 }
 128
 129 void
 130 _AppWidgetViewManager::RemoveAppWidgetView(_AppWidgetView* pAppWidgetView)
 131 {
 132         SysTryReturnVoidResult(NID_SHELL, pAppWidgetView, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 133
 134         livebox* pAppWidget = pAppWidgetView->GetNativeAppWidget();
 135         SysTryReturnVoidResult(NID_SHELL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 136
 137         livebox_del(pAppWidget, OnAppWidgetDeleted, this);
 138
 139         __pViewMap->Remove(pAppWidget);
 140 }
 141
 142 _AppWidgetView*
 143 _AppWidgetViewManager::GetAppWidgetView(livebox* pAppWidget) const
 144 {
 145         _AppWidgetView* pAppWidgetView = null;
 146         __pViewMap->GetValue(pAppWidget, pAppWidgetView);
 147
 148         return pAppWidgetView;
 149 }
 150
 151 FloatDimension
 152 _AppWidgetViewManager::GetAppWidgetSize(livebox* pAppWidget) const
 153 {
 154         SysTryReturn(NID_SHELL, pAppWidget, FloatDimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 155
 156         int width = 0;
 157         int height = 0;
 158
 159         int type = livebox_size(pAppWidget);
 160         livebox_service_get_size(type, &width, &height);
 161
 162 //      SysLog(NID_SHELL, "size [%d %d]", width, height);
 163
 164         return FloatDimension(width, height);
 165 }
 166
 167 FloatDimension
 168 _AppWidgetViewManager::GetAppWidgetPopupSize(livebox* pAppWidget) const
 169 {
 170         SysTryReturn(NID_SHELL, pAppWidget, FloatDimension(0, 0), E_SYSTEM, "[E_SYSTEM] A system error occurred.");
 171
 172         int width = 0;
 173         int height = 0;
 174
 175         livebox_get_pdsize(pAppWidget, &width, &height);
 176
 177 //      SysLog(NID_SHELL, "size [%d %d]", width, height);
 178
 179         return FloatDimension(width, height);
 180 }
 181
 182 void
 183 _AppWidgetViewManager::SetAppWidgetSize(const _AppWidgetView& appwidgetView, const FloatDimension& size)
 184 {
 185         livebox* pAppWidget = appwidgetView.GetNativeAppWidget();
 186         SysTryReturnVoidResult(NID_SHELL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 187
 188         int sizeType = GetAppWidgetSizeType(size);
 189
 190         livebox_resize(pAppWidget, sizeType, OnAppWidgetResized, this);
 191 }
 192
 193 void
 194 _AppWidgetViewManager::AddFrameEventListener(void)
 195 {
 196         if (!__pFrameEventListener)
 197         {
 198                 unique_ptr<_FrameEventListener> pFrameEventListener(new (std::nothrow) _FrameEventListener());
 199                 SysTryReturnVoidResult(NID_SHELL, pFrameEventListener, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 200
 201                 _Window* pWindow = _ControlManager::GetInstance()->GetCurrentFrame();
 202                 SysTryReturnVoidResult(NID_SHELL, pWindow, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 203
 204                 __pFrameEventListener = move(pFrameEventListener);
 205
 206                 _Frame* pFrame = dynamic_cast<_Frame*>(pWindow);
 207                 if (pFrame)
 208                 {
 209                         pFrame->AddFrameEventListener(*__pFrameEventListener);
 210                 }
 211
 212                 int ret = livebox_client_resumed();
 213                 SysLog(NID_SHELL, "ret (%d)", ret);
 214         }
 215 }
 216
 217 int
 218 _AppWidgetViewManager::GetAppWidgetSizeType(const Tizen::Graphics::FloatDimension& size) const
 219 {
 220         int sizeType = LB_SIZE_TYPE_UNKNOWN;
 221
 222         int sizetypeCount = sizeof(LIVEBOX_SIZE_INFO) / sizeof(_AppWidgetSizeInfo);
 223         for ( int i = 0; i < sizetypeCount; ++ i)
 224         {
 225                 if (size.width <= LIVEBOX_SIZE_INFO[i].width && size.height <= LIVEBOX_SIZE_INFO[i].height)
 226                 {
 227                         sizeType = LIVEBOX_SIZE_INFO[i].type;
 228                         break;
 229                 }
 230         }
 231
 232         SysLog(NID_SHELL, "[%f %f] type [%d][%d]", size.width, size.height, sizeType, sizetypeCount);
 233
 234         return sizeType;
 235 }
 236
 237 _AppWidgetViewManager::_AppWidgetViewManager(void)
 238         : __glMode(false)
 239         , __pAppWidgetBuffer(new (std::nothrow) _AppWidgetBuffer)
 240 {
 241 //      _LogicalResolution sourceResolution = RESOLUTION_LOGICAL_720;
 242 //      _PhysicalResolution destResolution = _CoordinateSystem::GetInstance()->GetPhysicalResolution();
 243
 244 #if defined(_DUMP_BUFFER)
 245         __pAppWidgetBuffer->Initialize();
 246 #endif // _DUMP_BUFFER
 247
 248         livebox_init(ecore_x_display_get());
 249         livebox_subscribe_group("*", "*");
 250
 251         __eventHandler.reset(livebox_set_event_handler(OnAppWidgetEventReceived, this));
 252         SysTryReturnVoidResult(NID_SHELL, __eventHandler == 0, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 253
 254         __faultEventHandler.reset(livebox_set_fault_handler(OnAppWidgetFaultReceived, this));
 255         SysTryReturnVoidResult(NID_SHELL, __faultEventHandler == 0, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 256
 257         unique_ptr<HashMapT<livebox*, _AppWidgetView*> > pViewMap(new (std::nothrow) HashMapT<livebox*, _AppWidgetView*>);
 258         SysTryReturnVoidResult(NID_SHELL, pViewMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 259
 260         result r = pViewMap->Construct();
 261         SysTryReturnVoidResult(NID_SHELL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 262
 263         __pViewMap = move(pViewMap);
 264         __glMode = IsGlMode();
 265
 266 //      r = _CreateCoordinateTransformer(__pCoordinateTransformer, sourceResolution, BASE_SCREEN_SIZE_NORMAL, destResolution, BASE_SCREEN_SIZE_NORMAL);
 267 //      SysTryCatch(NID_SHELL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 268 }
 269
 270 _AppWidgetViewManager::~_AppWidgetViewManager(void)
 271 {
 272         _ControlManager* pControlManager = _ControlManager::GetInstance();
 273         if (pControlManager && __pFrameEventListener)
 274         {
 275                 _Window* pWindow = pControlManager->GetCurrentFrame();
 276                 if (pWindow)
 277                 {
 278                         _Frame* pFrame = dynamic_cast<_Frame*>(pWindow);
 279                         if (pFrame)
 280                         {
 281                                 pFrame->RemoveFrameEventListener(*__pFrameEventListener);
 282                         }
 283                 }
 284         }
 285 }
 286
 287 MediaPixelFormat
 288 _AppWidgetViewManager::GetPixelFormat(BitmapPixelFormat format) const
 289 {
 290         MediaPixelFormat mediaPixelFormat = MEDIA_PIXEL_FORMAT_NONE;
 291
 292         switch(format)
 293         {
 294         case BITMAP_PIXEL_FORMAT_RGB565:
 295                 mediaPixelFormat = MEDIA_PIXEL_FORMAT_RGB565LE;
 296                 break;
 297
 298         case BITMAP_PIXEL_FORMAT_ARGB8888:
 299                 mediaPixelFormat = MEDIA_PIXEL_FORMAT_BGRA8888;
 300                 break;
 301
 302         case BITMAP_PIXEL_FORMAT_R8G8B8A8:
 303                 mediaPixelFormat = MEDIA_PIXEL_FORMAT_RGBA8888;
 304                 break;
 305
 306         default:
 307                 break;
 308         }
 309
 310         return mediaPixelFormat;
 311 }
 312
 313 Bitmap*
 314 _AppWidgetViewManager::GetBitmapN(const String& fileName) const
 315 {
 316         int width = 0;
 317         int height = 0;
 318
 319         MediaPixelFormat format = GetPixelFormat(BITMAP_PIXEL_FORMAT_ARGB8888);
 320
 321         unique_ptr<ByteBuffer> pByteBuffer(_ImageDecoder::DecodeToBufferN(fileName, format, width, height));
 322         SysTryReturn(NID_SHELL, pByteBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 323
 324         unique_ptr<Bitmap> pBitmap(_BitmapImpl::GetNonScaledBitmapN(*pByteBuffer, Dimension(width, height), BITMAP_PIXEL_FORMAT_ARGB8888));
 325         SysTryReturn(NID_SHELL, pBitmap, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 326
 327         return pBitmap.release();
 328 }
 329
 330 Bitmap*
 331 _AppWidgetViewManager::GetBitmapN(void* pBuffer, const FloatDimension& size) const
 332 {
 333         SysTryReturn(NID_SHELL, pBuffer, null, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 334
 335         byte* pTempBuffer = static_cast<byte*>(pBuffer);
 336         const int BITS_PER_PIXEL = 32;
 337         int length = size.width * size.height * BITS_PER_PIXEL / 8;
 338
 339         unique_ptr<ByteBuffer> pByteBuffer(new (std::nothrow) ByteBuffer());
 340         SysTryReturn(NID_SHELL, pByteBuffer, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 341
 342         result r = pByteBuffer->Construct(pTempBuffer, 0, length, length);
 343         SysTryReturn(NID_SHELL, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 344
 345         unique_ptr<Bitmap> pBitmap(_BitmapImpl::GetNonScaledBitmapN(*pByteBuffer.get(), Dimension(size.width, size.height), BITMAP_PIXEL_FORMAT_ARGB8888));
 346         SysTryReturn(NID_SHELL, pBitmap, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 347
 348         return pBitmap.release();
 349 }
 350
 351 bool
 352 _AppWidgetViewManager::IsGlMode(void) const
 353 {
 354         int mode = 0;
 355         bool glMode = false;
 356         String preferred(elm_config_preferred_engine_get());
 357         if(preferred == L"opengl_x11")
 358         {
 359                 glMode = true;
 360                 mode = 1;
 361         }
 362         else if(preferred == L"software_x11")
 363         {
 364                 glMode = false;
 365                 mode = 2;
 366         }
 367         else
 368         {
 369                 String engineConfig(elm_config_engine_get());
 370                 if(engineConfig == L"opengl_x11")
 371                 {
 372                         glMode = true;
 373                         mode = 3;
 374                 }
 375         }
 376
 377         SysLog(NID_SHELL, "[%d %d]", mode, glMode);
 378
 379         return glMode;
 380 }
 381
 382 void
 383 _AppWidgetViewManager::DumpBuffer(unsigned int pixmap, const char* pName)
 384 {
 385         if (__pAppWidgetBuffer->GetPixmap() != pixmap)
 386         {
 387                 int x = 0;
 388                 int y = 0;
 389                 int width = 0;
 390                 int height = 0;
 391
 392                 ecore_x_pixmap_geometry_get(pixmap, &x, &y, &width, &height);
 393                 SysTryReturnVoidResult(NID_SHELL, (width > 0) && (height > 0), E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid [0x%x %d %d].", pixmap, width , height);
 394
 395                 __pAppWidgetBuffer->DeallocBuffer();
 396                 __pAppWidgetBuffer->AllocBuffer(pixmap, FloatDimension(width, height));
 397                 __pAppWidgetBuffer->Dump(pName);
 398                 __pAppWidgetBuffer->UnlockBuffer();
 399         }
 400         else
 401         {
 402                 __pAppWidgetBuffer->LockBuffer();
 403                 __pAppWidgetBuffer->Dump(pName);
 404                 __pAppWidgetBuffer->UnlockBuffer();
 405         }
 406 }
 407
 408 void
 409 _AppWidgetViewManager::OnAppWidgetCreated(livebox* pAppWidget)
 410 {
 411 }
 412
 413 void
 414 _AppWidgetViewManager::OnAppWidgetUpdated(livebox* pAppWidget)
 415 {
 416         _AppWidgetView* pAppWidgetView = GetAppWidgetView(pAppWidget);
 417         SysTryReturnVoidResult(NID_SHELL, pAppWidgetView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 418
 419         int type = livebox_lb_type(pAppWidget);
 420
 421 //      SysLog(NID_SHELL, "type (%d)", type);
 422
 423         switch (type)
 424         {
 425         case LB_TYPE_IMAGE:
 426                 {
 427                         unique_ptr<Bitmap> pBitmap(GetBitmapN(livebox_filename(pAppWidget)));
 428                         SysTryReturnVoidResult(NID_SHELL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 429
 430                         pAppWidgetView->OnAppWidgetUpdated(*pBitmap.get(), GetAppWidgetSize(pAppWidget));
 431                         pBitmap.release();
 432                 }
 433                 break;
 434
 435         case LB_TYPE_BUFFER:
 436                 {
 437                         void* pBuffer = livebox_acquire_fb(pAppWidget);
 438                         SysTryReturnVoidResult(NID_SHELL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 439
 440                         FloatDimension sourceSize = GetAppWidgetSize(pAppWidget);
 441                         SysLog(NID_SHELL, "size [%d %d]", sourceSize.width, sourceSize.height);
 442
 443                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 444                         SysTryReturnVoidResult(NID_SHELL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 445
 446                         pAppWidgetView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 447                         livebox_release_fb(pBuffer);
 448                         pBitmap.release();
 449                 }
 450                 break;
 451
 452         case LB_TYPE_PIXMAP:
 453                 if (__glMode)
 454                 {
 455                         Pixmap pixmap = livebox_lb_pixmap(pAppWidget);
 456                         pAppWidgetView->OnAppWidgetUpdated(pixmap);
 457
 458 #if defined(_DUMP_BUFFER)
 459                         DumpBuffer(pixmap, "Box");
 460 #endif // _DUMP_BUFFER
 461                 }
 462                 else
 463                 {
 464                         void* pBuffer = livebox_acquire_fb(pAppWidget);
 465                         SysTryReturnVoidResult(NID_SHELL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 466
 467                         FloatDimension sourceSize = GetAppWidgetSize(pAppWidget);
 468
 469                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 470                         SysTryReturnVoidResult(NID_SHELL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 471
 472                         pAppWidgetView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 473                         livebox_release_fb(pBuffer);
 474                         pBitmap.release();
 475                 }
 476                 break;
 477
 478         default:
 479                 break;
 480         }
 481 }
 482
 483 void
 484 _AppWidgetViewManager::OnAppWidgetDeleted(livebox* pAppWidget)
 485 {
 486         _AppWidgetView* pAppWidgetView = GetAppWidgetView(pAppWidget);
 487         SysTryReturnVoidResult(NID_SHELL, pAppWidgetView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 488
 489         pAppWidgetView->CallProviderRemoved();
 490 }
 491
 492 void
 493 _AppWidgetViewManager::OnAppWidgetPinUpChanged(livebox* pAppWidget)
 494 {
 495 }
 496
 497 void
 498 _AppWidgetViewManager::OnAppWidgetPopupUpdated(livebox* pAppWidget)
 499 {
 500         _AppWidgetView* pAppWidgetView = GetAppWidgetView(pAppWidget);
 501         SysTryReturnVoidResult(NID_SHELL, pAppWidgetView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 502
 503         _AppWidgetPopupView* pAppWidgetPopupView = pAppWidgetView->GetAppWidgetPopup();
 504         SysTryReturnVoidResult(NID_SHELL, pAppWidgetPopupView, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 505
 506         int type = livebox_pd_type(pAppWidget);
 507
 508 //      SysLog(NID_SHELL, "type (%d)", type);
 509
 510         switch (type)
 511         {
 512         case PD_TYPE_BUFFER:
 513                 {
 514                         void* pBuffer = livebox_acquire_pdfb(pAppWidget);
 515                         SysTryReturnVoidResult(NID_SHELL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 516
 517                         FloatDimension sourceSize = GetAppWidgetPopupSize(pAppWidget);
 518
 519                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 520                         SysTryReturnVoidResult(NID_SHELL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 521
 522                         pAppWidgetPopupView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 523                         livebox_release_pdfb(pBuffer);
 524                         pBitmap.release();
 525                 }
 526                 break;
 527
 528         case PD_TYPE_PIXMAP:
 529                 if (__glMode)
 530                 {
 531                         Pixmap pixmap = livebox_pd_pixmap(pAppWidget);
 532                         pAppWidgetPopupView->OnAppWidgetUpdated(pixmap);
 533 #if defined(_DUMP_BUFFER)
 534                         DumpBuffer(pixmap, "Popup");
 535 #endif // _DUMP_BUFFER
 536                 }
 537                 else
 538                 {
 539                         void* pBuffer = livebox_acquire_pdfb(pAppWidget);
 540                         SysTryReturnVoidResult(NID_SHELL, pBuffer, E_SYSTEM, "[E_SYSTEM] A system error occured.");
 541
 542                         FloatDimension sourceSize = GetAppWidgetPopupSize(pAppWidget);
 543
 544                         unique_ptr<Bitmap> pBitmap(GetBitmapN(pBuffer, sourceSize));
 545                         SysTryReturnVoidResult(NID_SHELL, pBitmap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
 546
 547                         pAppWidgetPopupView->OnAppWidgetUpdated(*pBitmap.get(), sourceSize);
 548                         livebox_release_pdfb(pBuffer);
 549                         pBitmap.release();
 550                 }
 551                 break;
 552
 553         default:
 554                 break;
 555         }
 556 }
 557
 558 int
 559 _AppWidgetViewManager::OnAppWidgetEventReceived(livebox* pAppWidget, livebox_event_type eventType, void* pData)
 560 {
 561         SysTryReturn(NID_SHELL, pAppWidget, EXIT_SUCCESS, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 562
 563         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 564         SysTryReturn(NID_SHELL, pAppWidgetViewManager, EXIT_SUCCESS, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 565
 566         switch (eventType)
 567         {
 568         case LB_EVENT_LB_UPDATED:
 569                 pAppWidgetViewManager->OnAppWidgetUpdated(pAppWidget);
 570                 break;
 571
 572         case LB_EVENT_PD_UPDATED:
 573                 pAppWidgetViewManager->OnAppWidgetPopupUpdated(pAppWidget);
 574                 break;
 575
 576         case LB_EVENT_CREATED:
 577                 pAppWidgetViewManager->OnAppWidgetCreated(pAppWidget);
 578                 break;
 579
 580         case LB_EVENT_DELETED:
 581                 pAppWidgetViewManager->OnAppWidgetDeleted(pAppWidget);
 582                 break;
 583
 584         case LB_EVENT_GROUP_CHANGED:
 585                 break;
 586
 587         case LB_EVENT_PINUP_CHANGED:
 588                 pAppWidgetViewManager->OnAppWidgetPinUpChanged(pAppWidget);
 589                 break;
 590
 591         case LB_EVENT_PERIOD_CHANGED:
 592                 break;
 593
 594         default:
 595                 SysLog(NID_SHELL, "Not supported event type: %d", eventType);
 596                 break;
 597         }
 598
 599         return EXIT_SUCCESS;
 600 }
 601
 602 int
 603 _AppWidgetViewManager::OnAppWidgetFaultReceived(livebox_fault_type faultType, const char* pAppWidgetId, const char* pFilename, const char* pFuncName, void* pData)
 604 {
 605         if (faultType == LB_FAULT_DEACTIVATED)
 606         {
 607                 SysLog(NID_SHELL, "type (%d) packageName (%s) fileName (%s) funcName (%s)", faultType, pAppWidgetId, pFilename, pFuncName);
 608                 livebox_activate(pAppWidgetId, OnAppWidgetActivated, pData);
 609         }
 610
 611         return EXIT_SUCCESS;
 612 }
 613
 614 void
 615 _AppWidgetViewManager::OnAppWidgetActivated(livebox* pAppWidget, int ret, void* pData)
 616 {
 617         SysTryReturnVoidResult(NID_SHELL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 618         SysTryReturnVoidResult(NID_SHELL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 619
 620         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 621         SysTryReturnVoidResult(NID_SHELL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 622 }
 623
 624 void
 625 _AppWidgetViewManager::OnAppWidgetAdded(livebox* pAppWidget, int ret, void* pData)
 626 {
 627         SysTryReturnVoidResult(NID_SHELL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 628         SysTryReturnVoidResult(NID_SHELL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 629
 630         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 631         SysTryReturnVoidResult(NID_SHELL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 632 }
 633
 634 void
 635 _AppWidgetViewManager::OnAppWidgetDeleted(livebox* pAppWidget, int ret, void* pData)
 636 {
 637         SysTryReturnVoidResult(NID_SHELL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 638         SysTryReturnVoidResult(NID_SHELL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 639
 640         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 641         SysTryReturnVoidResult(NID_SHELL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 642 }
 643
 644 void
 645 _AppWidgetViewManager::OnAppWidgetResized(livebox* pAppWidget, int ret, void* pData)
 646 {
 647         SysTryReturnVoidResult(NID_SHELL, pAppWidget, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 648         SysTryReturnVoidResult(NID_SHELL, ret == 0, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 649
 650         _AppWidgetViewManager* pAppWidgetViewManager = static_cast<_AppWidgetViewManager*>(pData);
 651         SysTryReturnVoidResult(NID_SHELL, pAppWidgetViewManager, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
 652
 653 //      pAppWidgetViewManager->OnAppWidgetUpdated(pAppWidget);
 654 }
 655
 656 void
 657 _AppWidgetViewManager::_FrameEventListener::OnFrameActivated(const Tizen::Ui::Controls::_Frame& source)
 658 {
 659         int ret = livebox_client_resumed();
 660         SysLog(NID_SHELL, "ret (%d)", ret);
 661 }
 662
 663 void
 664 _AppWidgetViewManager::_FrameEventListener::OnFrameDeactivated(const Tizen::Ui::Controls::_Frame& source)
 665 {
 666         int ret = livebox_client_paused();
 667         SysLog(NID_SHELL, "ret (%d)", ret);
 668 }
 669
 670 void
 671 _AppWidgetViewManager::_FrameEventListener::OnFrameMinimized(const Tizen::Ui::Controls::_Frame& source)
 672 {
 673 }
 674
 675 void
 676 _AppWidgetViewManager::_FrameEventListener::OnFrameRestored(const Tizen::Ui::Controls::_Frame& source)
 677 {
 678 }
 679
 680 }} // Tizen::Shell