src/ui/controls/FUiCtrl_GalleryPresenter.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 #include <FBaseErrors.h>
  18 #include <FBaseRtTimer.h>
  19 #include <FBaseSysLog.h>
  20 #include "FUi_Math.h"
  21 #include "FUi_ResourceManager.h"
  22 #include "FUiCtrl_Gallery.h"
  23 #include "FUiCtrl_GalleryPresenter.h"
  24 #include "FUiCtrl_GalleryModel.h"
  25 #include "FUiCtrl_GalleryItem.h"
  26 #include "FUiCtrl_GalleryItemProvider.h"
  27 #include "FUiCtrl_GalleryCoreEvent.h"
  28 #include "FUiCtrl_GalleryCoreEventArg.h"
  29 #include "FUiCtrl_GalleryImageReader.h"
  30 #include "FUiCtrl_GalleryViewEventHandler.h"
  31 #include "FUiCtrl_IGalleryCoreEventListener.h"
  32 #include "FUiCtrl_IGalleryRenderer.h"
  33 #include "FUiCtrl_GalleryBitmap.h"
  34 #include "FUiCtrl_GalleryViewEvent.h"
  35 #include "FUiAnim_VisualElement.h"
  36
  37
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Graphics;
  40 using namespace Tizen::Ui;
  41
  42 namespace Tizen { namespace Ui { namespace Controls {
  43
  44 namespace
  45 {
  46
  47 const int DEFAULT_ITEM_SPACING = 30;
  48
  49 const int DEFAULT_ANIMATION_DURATION = 3000;
  50 const int MIN_ANIMATION_DURATION = 300;
  51 const int MAX_ANIMATION_DURATION = 20000;
  52 const int DEFAULT_VIEW_DURATION = 10;
  53 const int MIN_VIEW_DURATION = 10;
  54 const int FIRST_SLIDE_SHOW_DURATION = 1;
  55
  56 const int PARTIAL_CANVAS = 0;
  57 } // unnamed namespace
  58
  59 IMPLEMENT_PROPERTY(_GalleryPresenter);
  60
  61 _GalleryPresenter::_GalleryPresenter(_IGalleryRenderer& galleryRenderer)
  62         : __galleryRenderer(galleryRenderer)
  63         , __pGalleryViewEventHandler(null)
  64         , __pGalleryCoreEvent(null)
  65         , __pGalleryItemProvider(null)
  66         , __pGalleryModel(null)
  67         , __pGalleryImageReader(null)
  68         , __pEmptyGalleryImage(null)
  69         , __emptyText(L"")
  70         , __slideShowAnimationDuration(DEFAULT_ANIMATION_DURATION)
  71         , __slideShowViewDuration(DEFAULT_VIEW_DURATION)
  72         , __gallerySlideShowType(GALLERY_SLIDESHOW_DISSOLVE)
  73         , __currentItemIndex(NO_CURRENT_IMAGE)
  74         , __slideShowRepeat(false)
  75         , __slideShowStarted(false)
  76         , __zoomingEnabled(true)
  77         , __pSlideShowTimer(null)
  78         , __slideShowPlayCount(0)
  79         , __itemSpacing(DEFAULT_ITEM_SPACING)
  80         , __pItemToCanvas(null)
  81         , __fittingType(GALLERY_FITTING_TYPE_FIT)
  82         , __verticalAlignment(GALLERY_VERTICAL_ALIGN_MIDDLE)
  83         , __horizontalAlignment(GALLERY_HORIZONTAL_ALIGN_CENTER)
  84         , __emptyFontSize(0)
  85         , __emptyFontStyle(FONT_STYLE_PLAIN)
  86         , __pGalleryView(null)
  87 {
  88         AddPropertyChangeEventListener(*this);
  89 }
  90
  91 _GalleryPresenter::~_GalleryPresenter(void)
  92 {
  93         delete __pGalleryViewEventHandler;
  94         delete __pGalleryImageReader;
  95         delete __pGalleryModel;
  96         delete __pGalleryItemProvider;
  97         delete __pGalleryCoreEvent;
  98         delete __pEmptyGalleryImage;
  99         delete[] __pItemToCanvas;
 100         delete __pSlideShowTimer;
 101         __pSlideShowTimer = null;
 102 }
 103
 104 _GalleryPresenter*
 105 _GalleryPresenter::CreateGalleryPresenterN(_IGalleryRenderer& galleryRenderer,
 106                 _GalleryItemProviderAdaptorImpl* pGalleryItemProviderAdaptor, _Gallery* pGalleryView)
 107 {
 108         _GalleryPresenter* pPresenter = new (std::nothrow) _GalleryPresenter(galleryRenderer);
 109         SysTryReturn(NID_UI_CTRL, pPresenter != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 110
 111         result r = pPresenter->Construct(pGalleryItemProviderAdaptor, pGalleryView);
 112         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 113
 114         SetLastResult(E_SUCCESS);
 115         return pPresenter;
 116
 117 CATCH:
 118         delete pPresenter;
 119
 120         return null;
 121 }
 122
 123 result
 124 _GalleryPresenter::Construct(_GalleryItemProviderAdaptorImpl* pGalleryItemProviderAdaptor, _Gallery* pGalleryView)
 125 {
 126         SetLastResult(E_SUCCESS);
 127
 128         result r = E_SUCCESS;
 129
 130         __pGalleryCoreEvent = new (std::nothrow) _GalleryCoreEvent();
 131         SysTryCatch(NID_UI_CTRL, __pGalleryCoreEvent != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 132
 133         __pGalleryItemProvider = new (std::nothrow) _GalleryItemProvider(*__pGalleryCoreEvent, pGalleryItemProviderAdaptor);
 134         SysTryCatch(NID_UI_CTRL, __pGalleryItemProvider != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 135
 136         __pGalleryModel = _GalleryModel::CreateGalleryModelN(*__pGalleryItemProvider);
 137         SysTryCatch(NID_UI_CTRL, __pGalleryModel != null, , GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 138
 139         __pGalleryImageReader = new (std::nothrow) _GalleryImageReader(*__pGalleryModel);
 140         SysTryCatch(NID_UI_CTRL, __pGalleryImageReader != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 141
 142         __pItemToCanvas = new(std::nothrow) int[MAX_CANVAS_COUNT];
 143         SysTryCatch(NID_UI_CTRL, __pItemToCanvas != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 144         memset(__pItemToCanvas, -1, sizeof(int) * MAX_CANVAS_COUNT);
 145
 146         r = __galleryRenderer.SetCanvasMaxCount(MAX_CANVAS_COUNT);
 147         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 148
 149         r = __galleryRenderer.EnableEmptyView();
 150         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 151
 152         GET_STRING_CONFIG(IDS_COM_BODY_NO_IMAGES, __emptyText);
 153         r = __galleryRenderer.SetEmptyText(__emptyText);
 154         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 155
 156         __pGalleryViewEventHandler = new (std::nothrow) _GalleryViewEventHandler(*this, __galleryRenderer, *__pGalleryImageReader);
 157         SysTryCatch(NID_UI_CTRL, __pGalleryViewEventHandler != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 158
 159         r = __pGalleryViewEventHandler->Construct();
 160         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 161
 162         SetFontStyle(FONT_STYLE_PLAIN);
 163         SetFontSize(32);
 164
 165         __pGalleryView = pGalleryView;
 166
 167         return E_SUCCESS;
 168
 169 CATCH:
 170         delete __pGalleryViewEventHandler;
 171         delete __pGalleryImageReader;
 172         delete __pGalleryModel;
 173         delete __pGalleryItemProvider;
 174         delete __pGalleryCoreEvent;
 175         delete[] __pItemToCanvas;
 176
 177         return r;
 178 }
 179
 180 int
 181 _GalleryPresenter::GetCurrentItemIndex(void) const
 182 {
 183         return __currentItemIndex;
 184 }
 185
 186 result
 187 _GalleryPresenter::SetCurrentItemIndex(int index, bool eventFire)
 188 {
 189         SysTryReturn(NID_UI_CTRL, index < __pGalleryModel->GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 190                         "[E_OUT_OF_RANGE] The argument(%d) is out of range.", index);
 191
 192         if (__currentItemIndex != NO_CURRENT_IMAGE && __currentItemIndex != index)
 193         {
 194                 __currentItemIndex = index;
 195                 if (eventFire == true)
 196                 {
 197                         ChangedItem();
 198                 }
 199         }
 200         else
 201         {
 202                 __currentItemIndex = index;
 203         }
 204
 205         __pGalleryViewEventHandler->SetZoomFlag(false);
 206
 207         return E_SUCCESS;
 208 }
 209
 210 result
 211 _GalleryPresenter::SetCurrentItem(int index)
 212 {
 213         SysTryReturn(NID_UI_CTRL, index >=0 && index < __pGalleryModel->GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 214                                         "[E_OUT_OF_RANGE] The argument(%d) is out of range.", index);
 215
 216         int oldCurrentCanvasIndex = 0;
 217         result r = E_SUCCESS;
 218
 219         if (index == __currentItemIndex)
 220         {
 221                 return E_SUCCESS;
 222         }
 223
 224         if (__currentItemIndex != NO_CURRENT_IMAGE)
 225         {
 226                 oldCurrentCanvasIndex = SearchCanvasIndex(__currentItemIndex);
 227                 SysTryReturn(NID_UI_CTRL, oldCurrentCanvasIndex != NOT_EXIST_CANVAS, E_SYSTEM, E_SYSTEM,
 228                                         "[E_SYSTEM] The canvas of %d item is not exist.", oldCurrentCanvasIndex);
 229
 230                 if (__currentItemIndex > index)
 231                 {
 232                         FloatRectangle rect = __galleryRenderer.GetViewRect();
 233                         rect.x = rect.width;
 234                         r = __galleryRenderer.SetCanvasBounds(oldCurrentCanvasIndex, rect);
 235                 }
 236                 else if (__currentItemIndex < index)
 237                 {
 238                         FloatRectangle rect = __galleryRenderer.GetViewRect();
 239                         rect.x = -rect.width;
 240                         r = __galleryRenderer.SetCanvasBounds(oldCurrentCanvasIndex, rect);
 241                 }
 242
 243                 r = __galleryRenderer.SetCanvasVisibility(oldCurrentCanvasIndex, false);
 244                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 245         }
 246
 247         int newCurrentCanvasIndex = SearchCanvasIndex(index);
 248         if (newCurrentCanvasIndex == NOT_EXIST_CANVAS)
 249         {
 250                 r = SetCanvasImage(index);
 251                 SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 252                 newCurrentCanvasIndex = SearchCanvasIndex(index);
 253         }
 254         r = __galleryRenderer.SetCanvasBounds(newCurrentCanvasIndex, __galleryRenderer.GetViewRect());
 255         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 256
 257         r = __galleryRenderer.SetCanvasVisibility(newCurrentCanvasIndex, true);
 258         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 259
 260         r = SetCurrentItemIndex(index);
 261         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 262
 263         //RefreshView();
 264
 265         return E_SUCCESS;
 266
 267 CATCH:
 268         result resultValue = __galleryRenderer.SetCanvasVisibility(oldCurrentCanvasIndex, true);
 269         if (resultValue != E_SUCCESS)
 270         {
 271                 SysLog(NID_UI_CTRL, "[%s] Failed to setting of canvas visibility.", GetErrorMessage(resultValue));
 272         }
 273
 274         return r;
 275 }
 276
 277 int
 278 _GalleryPresenter::GetItemCount(void) const
 279 {
 280         return __pGalleryModel->GetItemCount();
 281 }
 282
 283 void
 284 _GalleryPresenter::SetItemSpacing(int spacing)
 285 {
 286         __itemSpacing = spacing;
 287 }
 288 int
 289 _GalleryPresenter::GetItemSpacing(void) const
 290 {
 291         return __itemSpacing;
 292 }
 293
 294 _GallerySlideShowType
 295 _GalleryPresenter::GetSlideShowType(void) const
 296 {
 297         return __gallerySlideShowType;
 298 }
 299
 300 result
 301 _GalleryPresenter::SetSlideShowType(_GallerySlideShowType slideShowType)
 302 {
 303         SysTryReturn(NID_UI_CTRL, slideShowType >= GALLERY_SLIDESHOW_DISSOLVE && slideShowType <= GALLERY_SLIDESHOW_PAGE,
 304                                 E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The animation argument(%d) is out of range", slideShowType);
 305
 306         __gallerySlideShowType = slideShowType;
 307
 308         return E_SUCCESS;
 309 }
 310
 311 int
 312 _GalleryPresenter::GetSlideShowAnimationDuration(void) const
 313 {
 314         Variant variant = GetProperty("slideShowAnimationDuration");
 315         return variant.ToInt();
 316 }
 317
 318 result
 319 _GalleryPresenter::SetSlideShowAnimationDuration(int duration)
 320 {
 321         SysTryReturn(NID_UI_CTRL, duration >= MIN_ANIMATION_DURATION && duration <= MAX_ANIMATION_DURATION,
 322                         E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The argument(%d) is out of range.", duration);
 323
 324         return SetProperty("slideShowAnimationDuration", Variant(duration));
 325 }
 326
 327 int
 328 _GalleryPresenter::GetSlideShowViewDuration(void) const
 329 {
 330         Variant variant = GetProperty("slideShowViewDuration");
 331         return variant.ToInt();
 332 }
 333
 334 result
 335 _GalleryPresenter::SetSlideShowViewDuration(int duration)
 336 {
 337         SysTryReturn(NID_UI_CTRL, duration >= MIN_VIEW_DURATION, E_OUT_OF_RANGE, E_OUT_OF_RANGE,
 338                         "[E_OUT_OF_RANGE] The argument(%d) is out of range.", duration);
 339
 340         return SetProperty("slideShowViewDuration", Variant(duration));
 341 }
 342
 343 result
 344 _GalleryPresenter::StartSlideShow(bool repeat)
 345 {
 346         SysTryReturn(NID_UI_CTRL, __pSlideShowTimer == null, E_INVALID_OPERATION, E_INVALID_OPERATION,
 347                         "[E_INVALID_OPERATION] Slide show is already started");
 348
 349         if (GetItemCount() == 0)
 350         {
 351                 return E_SUCCESS;
 352         }
 353
 354         __slideShowRepeat = repeat;
 355         __slideShowPlayCount = GetItemCount() - 1;
 356
 357         result r = StartSlideShowTimer(GetSlideShowViewDuration());
 358         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 359
 360         _GalleryCoreEventArg* pArg = new(std::nothrow) _GalleryCoreEventArg(GALLERY_CORE_EVENT_SLIDE_SHOW_STARTED);
 361         __pGalleryCoreEvent->Fire(*pArg);
 362
 363         return E_SUCCESS;
 364 }
 365
 366 result
 367 _GalleryPresenter::StopSlideShow(void)
 368 {
 369         SysTryReturn(NID_UI_CTRL, __pSlideShowTimer != null, E_INVALID_OPERATION, E_INVALID_OPERATION,
 370                         "[E_INVALID_OPERATION] Slide show is already stopped");
 371
 372         StopSlideShowTimer();
 373         __galleryRenderer.StopAllCanvasAnimation();
 374
 375         result r = __pGalleryViewEventHandler->SetVisibleCanvas();
 376         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 377
 378         _GalleryCoreEventArg* pArg = new(std::nothrow) _GalleryCoreEventArg(GALLERY_CORE_EVENT_SLIDE_SHOW_STOPPED);
 379         __pGalleryCoreEvent->Fire(*pArg);
 380
 381         r = __galleryRenderer.RefreshView();
 382         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 383
 384         return E_SUCCESS;
 385 }
 386
 387 String
 388 _GalleryPresenter::GetTextOfEmptyGallery(void) const
 389 {
 390         Variant variant = GetProperty("textOfEmptyGallery");
 391         return variant.ToString();
 392 }
 393
 394 result
 395 _GalleryPresenter::SetTextOfEmptyGallery(const String& text)
 396 {
 397         result r = __galleryRenderer.SetEmptyText(text);
 398         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 399
 400         return SetProperty("textOfEmptyGallery", Variant(text));
 401 }
 402
 403 result
 404 _GalleryPresenter::SetBitmapOfEmptyGallery(const _GalleryBitmap* pBitmap)
 405 {
 406         result r = __galleryRenderer.SetEmptyImage(pBitmap);
 407         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 408
 409         __pEmptyGalleryImage = const_cast <_GalleryBitmap*>(pBitmap);
 410
 411         return E_SUCCESS;
 412 }
 413
 414 bool
 415 _GalleryPresenter::IsSlideShowStarted(void) const
 416 {
 417         return __pSlideShowTimer != null ? true : false;
 418 }
 419
 420 result
 421 _GalleryPresenter::SetZoomingEnabled(bool enable)
 422 {
 423         return SetProperty("zoomingEnabled", Variant(enable));
 424 }
 425
 426 bool
 427 _GalleryPresenter::IsZoomingEnabled(void) const
 428 {
 429         Variant variant = GetProperty("zoomingEnabled");
 430
 431         return variant.ToBool();
 432 }
 433
 434 bool
 435 _GalleryPresenter::PostEvent(_GalleryViewEvent& event)
 436 {
 437         bool slideShowStarted = false;
 438         if (__pSlideShowTimer != null && event.GetEventType() != GALLERY_VIEW_EVENT_BOUNDS_CHANGED)
 439         {
 440                 result r = StopSlideShow();
 441                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 442                 slideShowStarted = true;
 443         }
 444
 445         if (GetItemCount() == 0)
 446         {
 447                 if (event.GetEventType() == GALLERY_VIEW_EVENT_BOUNDS_CHANGED)
 448                 {
 449                         return OnBoundsChanged();
 450                 }
 451                 //SetLastResult(E_SUCCESS);
 452                 return true;
 453         }
 454
 455         switch (event.GetEventType())
 456         {
 457         case GALLERY_VIEW_EVENT_TOUCH_PRESSED:
 458         {
 459                 if (slideShowStarted == true)
 460                 {
 461                         result r = __pGalleryViewEventHandler->SetVisibleCanvas();
 462                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r));
 463                         return true;
 464                 }
 465                 return __pGalleryViewEventHandler->OnTouchPressed(*(event.GetEventInfo()));
 466         }
 467
 468         case GALLERY_VIEW_EVENT_TOUCH_RELEASED:
 469                 return __pGalleryViewEventHandler->OnTouchReleased(*(event.GetEventInfo()));
 470
 471         case GALLERY_VIEW_EVENT_TOUCH_DOUBLE_PRESSED:
 472                 __galleryRenderer.SetCanvasVisibility(PARTIAL_CANVAS, false);
 473                 return __pGalleryViewEventHandler->OnTouchDoublePressed(*(event.GetEventInfo()));
 474
 475         case GALLERY_VIEW_EVENT_TOUCH_MOVED:
 476                 __galleryRenderer.SetCanvasVisibility(PARTIAL_CANVAS, false);
 477                 return __pGalleryViewEventHandler->OnTouchMoved(*(event.GetEventInfo()));
 478
 479         case GALLERY_VIEW_EVENT_TOUCH_PINCH_ZOOM:
 480                 return __pGalleryViewEventHandler->OnTouchPinchZoom(*(event.GetEventInfo()));
 481
 482         case GALLERY_VIEW_EVENT_TOUCH_FLICK:
 483                 //__galleryRenderer.SetCanvasVisibility(PARTIAL_CANVAS, false);
 484                 return __pGalleryViewEventHandler->OnTouchFlicked(*(event.GetEventInfo()));
 485
 486         case GALLERY_VIEW_EVENT_BOUNDS_CHANGED:
 487                 return OnBoundsChanged();
 488
 489         default:
 490                 SysTryReturn(NID_UI_CTRL, false, false, E_INVALID_ARG,
 491                                         "[E_INVALID_ARG] The event type(%d) is invalid type", event.GetEventType());
 492         }
 493
 494         //SetLastResult(E_SUCCESS);
 495         return true;
 496 }
 497
 498 bool
 499 _GalleryPresenter::OnBoundsChanged(void)
 500 {
 501         int itemIndex = -1;
 502         result r = E_SUCCESS;
 503
 504         r = __galleryRenderer.InitializeCanvasBounds();
 505         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 506
 507         if (GetItemCount() > 0)
 508         {
 509                 for (int canvasIndex = PARTIAL_CANVAS + 1; canvasIndex < MAX_CANVAS_COUNT; canvasIndex++)
 510                 {
 511                         itemIndex = __pItemToCanvas[canvasIndex];
 512                         if (itemIndex != NOT_EXIST_CANVAS)
 513                         {
 514                                 r = __galleryRenderer.SetCanvasImage(canvasIndex, __pGalleryImageReader->GetItemImage(itemIndex)
 515                                                 , __verticalAlignment, __horizontalAlignment, __fittingType);
 516                                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 517                         }
 518                 }
 519         }
 520         else
 521         {
 522                 r = __galleryRenderer.EnableEmptyView();
 523                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 524                 SetLastResult(E_SUCCESS);
 525                 return true;
 526         }
 527
 528         int currentItemIndex = GetCurrentItemIndex();
 529         int currentCanvasIndex = SearchCanvasIndex(currentItemIndex);
 530         int nextItemIndex = GetCurrentItemIndex() + 1;
 531         if (nextItemIndex >= GetItemCount())
 532         {
 533                 nextItemIndex = 0;
 534         }
 535         int nextCanvasIndex = SearchCanvasIndex(nextItemIndex);
 536
 537         r = __galleryRenderer.SetCanvasShowState(currentCanvasIndex, true);
 538         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 539
 540         if (__pSlideShowTimer != null && __slideShowStarted == true)
 541         {
 542                 r = __galleryRenderer.SetCanvasShowState(nextCanvasIndex, true);
 543                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 544         }
 545         else
 546         {
 547                 __galleryRenderer.GalleryBoundsChanged(currentCanvasIndex);
 548                 FloatRectangle canvasBounds = __galleryRenderer.GetCanvasBounds(currentCanvasIndex);
 549                 FloatRectangle imageBounds = __galleryRenderer.GetCanvasImageBounds(currentCanvasIndex);
 550                 __pGalleryViewEventHandler->CorrectCanvasPosition(canvasBounds, imageBounds);
 551                 r = __galleryRenderer.SetCanvasBounds(currentCanvasIndex, canvasBounds);
 552                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 553
 554                 r = __pGalleryViewEventHandler->AlignCanvas(false);
 555                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 556         }
 557
 558         SetLastResult(E_SUCCESS);
 559
 560         return true;
 561 }
 562
 563 void
 564 _GalleryPresenter::OnDraw(void)
 565 {
 566         result r = E_SUCCESS;
 567
 568         if (GetItemCount() > 0 && GetCurrentItemIndex() == NO_CURRENT_IMAGE)
 569         {
 570                 r = SetCurrentItem(0);
 571                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 572         }
 573
 574         r = __galleryRenderer.Draw();
 575         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 576
 577         SetLastResult(E_SUCCESS);
 578 }
 579
 580 result
 581 _GalleryPresenter::SetCoreEventListener(const _IGalleryCoreEventListener& coreEventListener)
 582 {
 583         return __pGalleryCoreEvent->AddListener(coreEventListener);
 584 }
 585
 586 result
 587 _GalleryPresenter::RemoveCoreEventListener(const _IGalleryCoreEventListener& coreEventListener)
 588 {
 589         return __pGalleryCoreEvent->RemoveListener(coreEventListener);
 590 }
 591
 592 bool
 593 _GalleryPresenter::ClickedItem(void)
 594 {
 595         _GalleryCoreEventArg* pArg = new(std::nothrow) _GalleryCoreEventArg(GALLERY_CORE_EVENT_ITEM_CLICKED, __currentItemIndex);
 596         return __pGalleryCoreEvent->Fire(*pArg);
 597 }
 598
 599 bool
 600 _GalleryPresenter::ChangedItem(void)
 601 {
 602         if (__currentItemIndex == NO_CURRENT_IMAGE)
 603         {
 604                 return true;
 605         }
 606
 607         __pGalleryView->ResizeGalleryAccessibilityElement();
 608
 609         _GalleryCoreEventArg* pArg = new(std::nothrow) _GalleryCoreEventArg(GALLERY_CORE_EVENT_CURRENT_ITEM_CHANGED, __currentItemIndex);
 610         return __pGalleryCoreEvent->Fire(*pArg);
 611 }
 612
 613 result
 614 _GalleryPresenter::RequestToLoadItem(int itemIndex)
 615 {
 616         result r = __pGalleryModel->RequestToLoadItem(itemIndex);
 617         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 618         SortItemToCanvasIndex(itemIndex, true);
 619
 620         if (GetItemCount() == 1)
 621         {
 622                 r = __galleryRenderer.DisableEmptyView();
 623                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 624
 625                 r = SetCurrentItem(itemIndex);
 626                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 627         }
 628
 629         r = __galleryRenderer.RefreshView();
 630         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 631
 632         return E_SUCCESS;
 633 }
 634
 635 result
 636 _GalleryPresenter::RequestToUnloadItem(int itemIndex)
 637 {
 638         result r = __pGalleryModel->RequestToUnloadItem(itemIndex);
 639         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 640
 641         int canvasIndex = SearchCanvasIndex(itemIndex);
 642         if (canvasIndex != NOT_EXIST_CANVAS)
 643         {
 644                 __galleryRenderer.SetCanvasVisibility(canvasIndex, false);
 645                 __pItemToCanvas[canvasIndex] = NOT_USED_CANVAS;
 646         }
 647         SortItemToCanvasIndex(itemIndex, false);
 648
 649         if (GetItemCount() == 0)
 650         {
 651                 r = SetCurrentItemIndex(NO_CURRENT_IMAGE);
 652                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 653
 654                 r = __galleryRenderer.EnableEmptyView();
 655                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 656         }
 657         else
 658         {
 659                 if (itemIndex < GetItemCount())
 660                 {
 661                         r = SetCanvasImage(itemIndex);
 662                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 663
 664                         int canvasIndex = SearchCanvasIndex(itemIndex);
 665                         SysTryReturn(NID_UI_CTRL, canvasIndex != NOT_EXIST_CANVAS, E_SYSTEM, E_SYSTEM,
 666                                                         "[E_SYSTEM] Failed to search canvas");
 667
 668                         r = __galleryRenderer.SetCanvasVisibility(canvasIndex, true);
 669                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 670                 }
 671                 else
 672                 {
 673                         r = SetCurrentItem(itemIndex - 1);
 674                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 675                 }
 676         }
 677
 678         r = __galleryRenderer.RefreshView();
 679         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 680
 681         return E_SUCCESS;
 682 }
 683
 684 result
 685 _GalleryPresenter::RequestToUnloadAllItems(void)
 686 {
 687         result r = __pGalleryModel->RequestToUnloadAllItems();
 688         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 689
 690         for (int i = 0; i < MAX_CANVAS_COUNT; i++)
 691         {
 692                 __pItemToCanvas[i] = NOT_USED_CANVAS;
 693         }
 694
 695         r = SetCurrentItemIndex(NO_CURRENT_IMAGE);
 696         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 697
 698         r = __galleryRenderer.EnableEmptyView();
 699         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 700
 701         //r = __galleryRenderer.RefreshView();
 702         //SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 703
 704         return E_SUCCESS;
 705 }
 706
 707 result
 708 _GalleryPresenter::RequestToUpdateItem(int itemIndex)
 709 {
 710         result r = __pGalleryModel->RequestToUpdateItem(itemIndex);
 711         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 712
 713         int canvasIndex = SearchCanvasIndex(itemIndex);
 714         if (itemIndex == GetCurrentItemIndex())
 715         {
 716                 _GalleryBitmap* pImage = __pGalleryImageReader->GetItemImage(itemIndex);
 717                 r = GetLastResult();
 718                 SysTryReturn(NID_UI_CTRL, pImage != null, r, r, "[%s] Propagating.", GetErrorMessage(r));
 719
 720                 r = __galleryRenderer.SetCanvasImage(canvasIndex, (const _GalleryBitmap*)pImage
 721                                 , __verticalAlignment, __horizontalAlignment, __fittingType);
 722                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 723
 724                 __galleryRenderer.GalleryBoundsChanged(canvasIndex);
 725         }
 726         else if (canvasIndex != NOT_EXIST_CANVAS)
 727         {
 728                 __pItemToCanvas[canvasIndex] = NOT_USED_CANVAS;
 729         }
 730
 731         r = __galleryRenderer.RefreshView();
 732         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 733
 734         return E_SUCCESS;
 735 }
 736
 737 result
 738 _GalleryPresenter::RequestToUpdateAllItems(void)
 739 {
 740         result r = __pGalleryModel->RequestToUpdateAllItems();
 741         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 742
 743         r = __galleryRenderer.ResetAllCanvas();
 744         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 745
 746         for (int i = 0; i < MAX_CANVAS_COUNT; i++)
 747         {
 748                 __pItemToCanvas[i] = NOT_USED_CANVAS;
 749         }
 750
 751         int itemCount = GetItemCount();
 752         if (itemCount > 0)
 753         {
 754                 r = __galleryRenderer.DisableEmptyView();
 755                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 756
 757                 if (GetCurrentItemIndex() != NO_CURRENT_IMAGE)
 758                 {
 759                         r = SetCanvasImage(GetCurrentItemIndex());
 760                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 761
 762                         r = __galleryRenderer.SetCanvasVisibility(SearchCanvasIndex(GetCurrentItemIndex()), true);
 763                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 764                 }
 765                 else
 766                 {
 767                         r = SetCurrentItem(0);
 768                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 769
 770                         r = __galleryRenderer.SetCanvasVisibility(SearchCanvasIndex(0), true);
 771                         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 772                 }
 773         }
 774         else
 775         {
 776                 r = __galleryRenderer.EnableEmptyView();
 777                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 778         }
 779
 780         return E_SUCCESS;
 781 }
 782
 783 result
 784 _GalleryPresenter::RequestToUpdateItemCount(void)
 785 {
 786         __pGalleryModel->UpdateItemCount();
 787
 788         return E_SUCCESS;
 789 }
 790
 791 void
 792 _GalleryPresenter::OnTimerExpired(Runtime::Timer& timer)
 793 {
 794         result r = E_SUCCESS;
 795         if (&timer == __pSlideShowTimer)
 796         {
 797                 r = PlaySlideShow();
 798                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 799         }
 800         SetLastResult(E_SUCCESS);
 801 }
 802
 803 void
 804 _GalleryPresenter::OnTransitionCancel(void)
 805 {
 806         __slideShowStarted = false;
 807         int endItemIndex = __currentItemIndex + 1;
 808         if (GetItemCount() > 0)
 809         {
 810                 endItemIndex = endItemIndex % GetItemCount();
 811         }
 812         else
 813         {
 814                 endItemIndex = 0;
 815         }
 816
 817         result r = SetCurrentItemIndex(endItemIndex);
 818         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 819
 820         StopSlideShowTimer();
 821 }
 822
 823 void
 824 _GalleryPresenter::OnTransitionCompleted(void)
 825 {
 826         __slideShowStarted = false;
 827         if (__slideShowPlayCount > 0 || __slideShowRepeat == true)
 828         {
 829                 StartSlideShowTimer(GetSlideShowViewDuration());
 830         }
 831         else
 832         {
 833                 result r = StopSlideShow();
 834                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating", GetErrorMessage(r));
 835         }
 836
 837         int endItemIndex = __currentItemIndex + 1;
 838         if (GetItemCount() > 0)
 839         {
 840                 endItemIndex = endItemIndex % GetItemCount();
 841         }
 842         else
 843         {
 844                 endItemIndex = 0;
 845         }
 846
 847         result r = SetCurrentItemIndex(endItemIndex);
 848         SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 849
 850         SetLastResult(E_SUCCESS);
 851 }
 852
 853 void
 854 _GalleryPresenter::OnCanvasAnimationCancel(void)
 855 {
 856 }
 857
 858 void
 859 _GalleryPresenter::OnCanvasAnimationCompleted(void)
 860 {
 861 }
 862
 863 void
 864 _GalleryPresenter::OnCanvasAnimationStarted(void)
 865 {
 866         __slideShowStarted = true;
 867 }
 868
 869 result
 870 _GalleryPresenter::SetCanvasImage(int itemIndex)
 871 {
 872         SysTryReturn(NID_UI_CTRL, itemIndex >= 0, E_INVALID_ARG, E_INVALID_ARG,
 873                                         "[E_INVALID_ARG] The argument(%d) is negative value.", itemIndex);
 874         SysTryReturn(NID_UI_CTRL, itemIndex >=0 && itemIndex < __pGalleryModel->GetItemCount(),
 875                                         E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The argument(%d) is out of range.", itemIndex);
 876
 877         if (SearchCanvasIndex(itemIndex) != NOT_EXIST_CANVAS)
 878         {
 879                 return E_SUCCESS;
 880         }
 881
 882         int emptyCanvasIndex = GetEmptyCanvasIndex();
 883         if (emptyCanvasIndex == NOT_EXIST_CANVAS)
 884         {
 885                 emptyCanvasIndex = ClearCanvasIndex(__currentItemIndex);
 886         }
 887
 888         _GalleryBitmap* pImage = __pGalleryImageReader->GetItemImage(itemIndex);
 889         result r = GetLastResult();
 890         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 891
 892         __pItemToCanvas[emptyCanvasIndex] = itemIndex;
 893         r = __galleryRenderer.SetCanvasImage(emptyCanvasIndex, (const _GalleryBitmap*)pImage
 894                         , __verticalAlignment, __horizontalAlignment, __fittingType);
 895         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 896
 897         FloatRectangle bounds = __galleryRenderer.GetViewRect();
 898         r = __galleryRenderer.SetCanvasBounds(emptyCanvasIndex, bounds);
 899         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 900
 901         r = __galleryRenderer.SetCanvasVisibility(emptyCanvasIndex, false);
 902         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
 903
 904         return E_SUCCESS;
 905 }
 906
 907 result
 908 _GalleryPresenter::SetPartialCanvasImage(void)
 909 {
 910         SysTryReturn(NID_UI_CTRL, __currentItemIndex >= 0, E_INVALID_ARG, E_INVALID_ARG,
 911                                 "[E_INVALID_ARG] The argument(%d) is negative value.", __currentItemIndex);
 912
 913         _GalleryItem* pGalleryItem = __pGalleryModel->GetItem(__currentItemIndex);
 914         if (pGalleryItem->GetGalleryItemFilePath() == L"")
 915         {
 916                 return E_SUCCESS;
 917         }
 918
 919         int currentCanvasIndex = SearchCanvasIndex(__currentItemIndex);
 920
 921         FloatRectangle canvasBounds = __galleryRenderer.GetCanvasBounds(currentCanvasIndex);
 922         FloatRectangle imageBounds = __galleryRenderer.GetCanvasImageBounds(currentCanvasIndex);
 923         FloatRectangle viewBounds = __galleryRenderer.GetViewRect();
 924
 925         if (imageBounds.width < viewBounds.width)
 926         {
 927                 imageBounds.x -= (viewBounds.width - imageBounds.width) / 2;
 928         }
 929
 930         if (imageBounds.height < viewBounds.height)
 931         {
 932                 imageBounds.y -= (viewBounds.height - imageBounds.height) / 2;
 933         }
 934
 935         canvasBounds.x = _Abs(-canvasBounds.x - imageBounds.x);
 936         canvasBounds.y = _Abs(-canvasBounds.y - imageBounds.y);
 937         canvasBounds.width = viewBounds.width < imageBounds.width ? viewBounds.width : imageBounds.width;
 938         canvasBounds.height = viewBounds.height < imageBounds.height ? viewBounds.height : imageBounds.height;
 939
 940         FloatDimension size(imageBounds.width, imageBounds.height);
 941
 942         _GalleryBitmap* pImage = __pGalleryImageReader->GetPartialImageFromFileN(__currentItemIndex, canvasBounds, size);
 943         SysTryReturn(NID_UI_CTRL, pImage != null, GetLastResult(), GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 944
 945         __pItemToCanvas[PARTIAL_CANVAS] = __currentItemIndex;
 946         result r = __galleryRenderer.SetCanvasImage(PARTIAL_CANVAS, (const _GalleryBitmap*)pImage
 947                         , GALLERY_VERTICAL_ALIGN_MIDDLE, GALLERY_HORIZONTAL_ALIGN_CENTER,  __fittingType);
 948         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 949
 950         r = __galleryRenderer.SetCanvasBounds(PARTIAL_CANVAS, viewBounds);
 951         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 952
 953         r = __galleryRenderer.SetCanvasVisibility(PARTIAL_CANVAS, true);
 954         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 955
 956         delete pImage;
 957
 958         return E_SUCCESS;
 959 CATCH:
 960         delete pImage;
 961
 962         return r;
 963 }
 964
 965 int
 966 _GalleryPresenter::SearchCanvasIndex(int itemIndex)
 967 {
 968         if (itemIndex == NO_CURRENT_IMAGE)
 969         {
 970                 return NOT_EXIST_CANVAS;
 971         }
 972
 973         for (int i = 1; i < MAX_CANVAS_COUNT; i++)
 974         {
 975                 if (__pItemToCanvas[i] == itemIndex)
 976                 {
 977                         return i;
 978                 }
 979         }
 980
 981         return NOT_EXIST_CANVAS;
 982 }
 983
 984 int
 985 _GalleryPresenter::GetEmptyCanvasIndex(void) const
 986 {
 987         for (int i = 1; i < MAX_CANVAS_COUNT; i++)
 988         {
 989                 if (__pItemToCanvas[i] == NOT_USED_CANVAS)
 990                 {
 991                         return i;
 992                 }
 993         }
 994         return NOT_EXIST_CANVAS;
 995 }
 996
 997 result
 998 _GalleryPresenter::SetCanvasIndex(int canvasIndex, int itemIndex)
 999 {
1000         SysTryReturn(NID_UI_CTRL, canvasIndex >= 0, E_INVALID_ARG, E_INVALID_ARG,
1001                                         "[E_INVALID_ARG] The argument(%d) is negative value.", canvasIndex);
1002         SysTryReturn(NID_UI_CTRL, canvasIndex > 0 && canvasIndex < MAX_CANVAS_COUNT, E_OUT_OF_RANGE, E_OUT_OF_RANGE,
1003                                         "[E_OUT_OF_RANGE] The canvas index(%d) is out of range", canvasIndex);
1004         SysTryReturn(NID_UI_CTRL, itemIndex >= 0, E_INVALID_ARG, E_INVALID_ARG,
1005                                         "[E_INVALID_ARG] The argument(%d) is negative value.", itemIndex);
1006         SysTryReturn(NID_UI_CTRL, itemIndex >=0 && itemIndex < __pGalleryModel->GetItemCount(), E_OUT_OF_RANGE, E_OUT_OF_RANGE,
1007                         "[E_OUT_OF_RANGE] The argument(%d) is out of range.", itemIndex);
1008
1009         if (__pItemToCanvas[canvasIndex] == NOT_USED_CANVAS)
1010         {
1011                 __pItemToCanvas[canvasIndex] = itemIndex;
1012         }
1013         else
1014         {
1015                 SysTryReturn(NID_UI_CTRL, false, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The canvas index(%d) is used.", canvasIndex);
1016         }
1017
1018         return E_SUCCESS;
1019 }
1020
1021 int
1022 _GalleryPresenter::ClearCanvasIndex(int currentItemIndex)
1023 {
1024         SysTryReturn(NID_UI_CTRL, currentItemIndex >= 0, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument(%d) is negative value.", currentItemIndex);
1025
1026         int clearCanvasIndex = 1;
1027         int maxAbsValue = 0;
1028         int absValue = 0;
1029
1030         for (int i = 1; i < MAX_CANVAS_COUNT; i++)
1031         {
1032                 absValue = _Abs(currentItemIndex - __pItemToCanvas[i]);
1033                 if (absValue > maxAbsValue)
1034                 {
1035                         maxAbsValue = absValue;
1036                         clearCanvasIndex = i;
1037                 }
1038         }
1039         __pItemToCanvas[clearCanvasIndex] = NOT_USED_CANVAS;
1040
1041         SetLastResult(E_SUCCESS);
1042         return clearCanvasIndex;
1043 }
1044
1045 void
1046 _GalleryPresenter::SortItemToCanvasIndex(int itemIndex, bool add)
1047 {
1048         if (add == true)
1049         {
1050                 for (int i = 0; i < MAX_CANVAS_COUNT; i++)
1051                 {
1052                         if (__pItemToCanvas[i] >= itemIndex)
1053                         {
1054                                 __pItemToCanvas[i]++;
1055                         }
1056                 }
1057         }
1058         else
1059         {
1060                 for (int i = 0; i < MAX_CANVAS_COUNT; i++)
1061                 {
1062                         if (__pItemToCanvas[i] > itemIndex)
1063                         {
1064                                 __pItemToCanvas[i]--;
1065                         }
1066                 }
1067         }
1068 }
1069
1070 result
1071 _GalleryPresenter::StartSlideShowTimer(int duration)
1072 {
1073         result r = E_SUCCESS;
1074         if (__pSlideShowTimer != null)
1075         {
1076                 delete __pSlideShowTimer;
1077                 __pSlideShowTimer = null;
1078         }
1079
1080         __pSlideShowTimer = new(std::nothrow) Runtime::Timer();
1081         SysTryCatch(NID_UI_CTRL, __pSlideShowTimer != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
1082
1083         r = __pSlideShowTimer->Construct(*this);
1084         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1085
1086         __pSlideShowTimer->Start(duration);
1087         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
1088
1089         return E_SUCCESS;
1090
1091 CATCH:
1092         delete __pSlideShowTimer;
1093         __pSlideShowTimer = null;
1094
1095         return GetLastResult();
1096 }
1097
1098 void
1099 _GalleryPresenter::StopSlideShowTimer(void)
1100 {
1101         delete __pSlideShowTimer;
1102         __pSlideShowTimer = null;
1103
1104         __slideShowRepeat = false;
1105         __slideShowPlayCount = 0;
1106 }
1107
1108 result
1109 _GalleryPresenter::PlaySlideShow(void)
1110 {
1111         int startCanvasIndex = SearchCanvasIndex(__currentItemIndex);
1112         SysTryReturn(NID_UI_CTRL, startCanvasIndex != NOT_EXIST_CANVAS, E_SYSTEM, E_SYSTEM,
1113                                 "[E_SYSTEM] The current item not exist.");
1114
1115         int endItemIndex = __currentItemIndex + 1;
1116         if (endItemIndex >= GetItemCount())
1117         {
1118                 endItemIndex = 0;
1119         }
1120
1121         result r = __galleryRenderer.SetCanvasVisibility(PARTIAL_CANVAS, false);
1122         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1123
1124         r = __galleryRenderer.SetCanvasVisibility(startCanvasIndex, true);
1125         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1126
1127         int endCanvasIndex = SearchCanvasIndex(endItemIndex);
1128         if (endCanvasIndex == NOT_EXIST_CANVAS)
1129         {
1130                 r = SetCanvasImage(endItemIndex);
1131                 SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1132                 endCanvasIndex = SearchCanvasIndex(endItemIndex);
1133         }
1134
1135         _GalleryTransitionType transition = static_cast<_GalleryTransitionType>(GetSlideShowType());
1136         _GalleryAnimationTiming animation = {__slideShowAnimationDuration, GALLERY_ANIMATION_TIMING_FUNC_EASEOUT};
1137         r = __galleryRenderer.SetCanvasVisibility(endCanvasIndex, true);
1138         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1139
1140         r = __galleryRenderer.RunCanvasTransition(startCanvasIndex, endCanvasIndex, transition, &animation);
1141         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1142
1143         if (__slideShowRepeat == false)
1144         {
1145                 __slideShowPlayCount--;
1146         }
1147
1148         r = __galleryRenderer.RefreshView();
1149         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
1150
1151         return E_SUCCESS;
1152 }
1153
1154 // property access
1155 Variant
1156 _GalleryPresenter::GetPropertySlideShowViewDuration(void) const
1157 {
1158         return Variant(__slideShowViewDuration);
1159 }
1160
1161 result
1162 _GalleryPresenter::SetPropertySlideShowViewDuration(const Variant& variant)
1163 {
1164         __slideShowViewDuration = variant.ToInt();
1165
1166         return E_SUCCESS;
1167 }
1168
1169 Variant
1170 _GalleryPresenter::GetPropertySlideShowAnimationDuration(void) const
1171 {
1172         return Variant(__slideShowAnimationDuration);
1173 }
1174
1175 result
1176 _GalleryPresenter::SetPropertySlideShowAnimationDuration(const Variant& variant)
1177 {
1178         __slideShowAnimationDuration = variant.ToInt();
1179
1180         return E_SUCCESS;
1181 }
1182
1183 Variant
1184 _GalleryPresenter::GetPropertyTextOfEmptyGallery(void) const
1185 {
1186         return Variant(__emptyText);
1187 }
1188
1189 result
1190 _GalleryPresenter::SetPropertyTextOfEmptyGallery(const Variant& variant)
1191 {
1192         __emptyText = variant.ToString();
1193
1194         return E_SUCCESS;
1195 }
1196
1197 Variant
1198 _GalleryPresenter::GetPropertyZoomingEnabled(void) const
1199 {
1200         return Variant(__zoomingEnabled);
1201 }
1202
1203 result
1204 _GalleryPresenter::SetPropertyZoomingEnabled(const Variant& variant)
1205 {
1206         __zoomingEnabled = variant.ToBool();
1207
1208         return E_SUCCESS;
1209 }
1210
1211 void
1212 _GalleryPresenter::OnPropertyChanging(_PropertyBase& source, const String& name,
1213                                                                                                                         const Variant& oldProperty, const Variant& newProperty)
1214 {
1215 }
1216
1217 void
1218 _GalleryPresenter::OnPropertyChanged(_PropertyBase& source, const String& name,
1219                                                                                                                         const Variant& oldProperty, const Variant& newProperty)
1220 {
1221 }
1222
1223 void
1224 _GalleryPresenter::SetFontSize(int size)
1225 {
1226         __emptyFontSize = size;
1227 }
1228
1229 int
1230 _GalleryPresenter::GetFontSize(void) const
1231 {
1232         return __emptyFontSize;
1233 }
1234
1235 void
1236 _GalleryPresenter::SetFontStyle(FontStyle style)
1237 {
1238         __emptyFontStyle = style;
1239 }
1240
1241 FontStyle
1242 _GalleryPresenter::GetFontStyle(void) const
1243 {
1244         return __emptyFontStyle;
1245 }
1246
1247 void
1248 _GalleryPresenter::OnFontInfoRequested(unsigned long& style, int& size)
1249 {
1250         style = GetFontStyle();
1251         size = GetFontSize();
1252 }
1253
1254 void
1255 _GalleryPresenter::OnFontChanged(void)
1256 {
1257         if (GetItemCount() == 0)
1258         {
1259                 result r = __galleryRenderer.EnableEmptyView();
1260                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
1261         }
1262 }
1263
1264 }}} // Tizen::Ui::Controls