src/ui/controls/FUiCtrl_Gallery.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 #include <FBaseString.h>
  18 #include <FGrpColor.h>
  19 #include <FSys_SettingInfoImpl.h>
  20 #include "FUi_AccessibilityContainer.h"
  21 #include "FUi_AccessibilityElement.h"
  22 #include "FUi_AccessibilityManager.h"
  23 #include "FUi_CoordinateSystemUtils.h"
  24 #include "FUi_ResourceManager.h"
  25 #include "FUi_TouchFlickGestureDetector.h"
  26 #include "FUi_TouchTapGestureDetector.h"
  27 #include "FUi_TouchPinchGestureDetector.h"
  28 #include "FUi_TouchLongPressGestureDetector.h"
  29 #include "FUiCtrl_Gallery.h"
  30 #include "FUiCtrl_GalleryBitmap.h"
  31 #include "FUiCtrl_GalleryPresenter.h"
  32 #include "FUiCtrl_GalleryRenderer.h"
  33 #include "FUiCtrl_GalleryRendererNotification.h"
  34 #include "FUiCtrl_GalleryViewEventInfo.h"
  35 #include "FUiCtrl_GalleryViewEvent.h"
  36 #include "FUiCtrl_IGalleryCoreEventListener.h"
  37 #include "FUiCtrl_IGalleryRendererNotiListener.h"
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Graphics;
  41 using namespace Tizen::System;
  42 using namespace Tizen::Ui::Effects;
  43
  44 namespace {
  45         const float TOUCH_INSENSITIVE = 0.08f;
  46         const int GALLERY_GESTURE_TAP_MOVE_ALLOWANCE = 50;
  47 } // unnamed namespace
  48
  49 namespace Tizen { namespace Ui { namespace Controls {
  50
  51 _Gallery::_Gallery(void)
  52         : __pRenderer(null)
  53         , __pPresenter(null)
  54         , __modelInitialized(false)
  55         , __longPressed(false)
  56         , __keyEventProcessing(false)
  57         , __pGalleryImageElement(null)
  58 {
  59         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
  60         if (pContainer != null)
  61         {
  62                 pContainer->Activate(true);
  63         }
  64 }
  65
  66 _Gallery::~_Gallery(void)
  67 {
  68         result r = __flickGesture.RemoveGestureListener(*this);
  69         if (r != E_SUCCESS)
  70         {
  71                 SetLastResult(r);
  72                 SysAssert(false);
  73         }
  74
  75         r = RemoveGestureDetector(__flickGesture);
  76         if (r != E_SUCCESS)
  77         {
  78                 SetLastResult(r);
  79                 SysAssert(false);
  80         }
  81
  82         r = __oneTapGesture.RemoveGestureListener(*this);
  83         if (r != E_SUCCESS)
  84         {
  85                 SetLastResult(r);
  86                 SysAssert(false);
  87         }
  88
  89         r = RemoveGestureDetector(__oneTapGesture);
  90         if (r != E_SUCCESS)
  91         {
  92                 SetLastResult(r);
  93                 SysAssert(false);
  94         }
  95
  96         r = __twoTapGesture.RemoveGestureListener(*this);
  97         if (r != E_SUCCESS)
  98         {
  99                 SetLastResult(r);
 100                 SysAssert(false);
 101         }
 102
 103         r = RemoveGestureDetector(__twoTapGesture);
 104         if (r != E_SUCCESS)
 105         {
 106                 SetLastResult(r);
 107                 SysAssert(false);
 108         }
 109
 110         r = __pinchGesture.RemoveGestureListener(*this);
 111         if (r != E_SUCCESS)
 112         {
 113                 SetLastResult(r);
 114                 SysAssert(false);
 115         }
 116
 117         r = RemoveGestureDetector(__pinchGesture);
 118         if (r != E_SUCCESS)
 119         {
 120                 SetLastResult(r);
 121                 SysAssert(false);
 122         }
 123
 124         r = __longPressGesture.RemoveGestureListener(*this);
 125         if (r != E_SUCCESS)
 126         {
 127                 SetLastResult(r);
 128                 SysAssert(false);
 129         }
 130
 131         r = RemoveGestureDetector(__longPressGesture);
 132         if (r != E_SUCCESS)
 133         {
 134                 SetLastResult(r);
 135                 SysAssert(false);
 136         }
 137
 138         r = _SettingInfoImpl::RemoveSettingEventListenerForInternal(*this);
 139         if (r != E_SUCCESS)
 140         {
 141                 SetLastResult(r);
 142                 SysAssert(false);
 143         }
 144
 145         RemoveGalleryAccessibilityElements();
 146
 147         delete __pRenderer;
 148         delete __pPresenter;
 149 }
 150
 151 _Gallery*
 152 _Gallery::CreateGalleryN(_GalleryItemProviderAdaptorImpl* pGalleryItemProviderAdaptor)
 153 {
 154         result r = E_SUCCESS;
 155         ClearLastResult();
 156
 157         _Gallery* pGallery = new (std::nothrow) _Gallery();
 158         SysTryCatch(NID_UI_CTRL, pGallery != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to allocate the memory for the _Gallery.");
 159
 160         r = pGallery->Construct(pGalleryItemProviderAdaptor);
 161         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 162
 163         SetLastResult(E_SUCCESS);
 164
 165         return pGallery;
 166
 167 CATCH:
 168         delete pGallery;
 169
 170         return null;
 171 }
 172
 173 result
 174 _Gallery::Construct(_GalleryItemProviderAdaptorImpl* pGalleryItemProviderAdaptor)
 175 {
 176         result r = E_SUCCESS;
 177         _GalleryRenderer* pRenderer = null;
 178         _GalleryPresenter* pPresenter = null;
 179
 180         pRenderer = _GalleryRenderer::CreateGalleryRendererN((Tizen::Ui::_Control&)*this);
 181         SysTryCatch(NID_UI_CTRL, pRenderer != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the _GalleryRenderer.");
 182
 183         pPresenter = _GalleryPresenter::CreateGalleryPresenterN((_IGalleryRenderer&)*pRenderer, pGalleryItemProviderAdaptor, this);
 184         SysTryCatch(NID_UI_CTRL, pPresenter != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the _GalleryPresenter.");
 185
 186         r = pRenderer->AddNotiListener(*pPresenter);
 187         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 188
 189         AcquireHandle();
 190
 191         r = __flickGesture.AddGestureListener(*this);
 192         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 193
 194         r = _Control::AddGestureDetector(__flickGesture);
 195         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 196
 197         r = __oneTapGesture.AddGestureListener(*this);
 198         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 199
 200         __oneTapGesture.SetTapCount(1);
 201         r = _Control::AddGestureDetector(__oneTapGesture);
 202         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 203
 204         r = __twoTapGesture.AddGestureListener(*this);
 205         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 206
 207         r = __twoTapGesture.SetMoveAllowance(GALLERY_GESTURE_TAP_MOVE_ALLOWANCE);
 208         SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Failed to set TapMoveAllowance", GetErrorMessage(r));
 209
 210         __twoTapGesture.SetTapCount(2);
 211         r = _Control::AddGestureDetector(__twoTapGesture);
 212         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 213
 214         __oneTapGesture.StartOnFailureOf(__twoTapGesture);
 215
 216         SetMultiTouchEnabled(true);
 217         r = _Control::AddGestureDetector(__pinchGesture);
 218         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 219
 220         r = __pinchGesture.AddGestureListener(*this);
 221         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 222
 223         r = __longPressGesture.AddGestureListener(*this);
 224         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 225
 226         r = _Control::AddGestureDetector(__longPressGesture);
 227         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 228
 229         r = _SettingInfoImpl::AddSettingEventListenerForInternal(*this);
 230         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 231
 232         SetTouchPressThreshold(TOUCH_INSENSITIVE);
 233
 234         SetRenderer((_GalleryRenderer &)*pRenderer);
 235         SetPresenter((_GalleryPresenter &)*pPresenter);
 236
 237         return E_SUCCESS;
 238
 239 CATCH:
 240         delete pRenderer;
 241         delete pPresenter;
 242
 243         return r;
 244 }
 245
 246 // presenter access
 247 result
 248 _Gallery::SetTextOfEmptyGallery(const String& text)
 249 {
 250         return GetPresenter().SetTextOfEmptyGallery(text);
 251 }
 252
 253 String
 254 _Gallery::GetTextOfEmptyGallery(void) const
 255 {
 256         return GetPresenter().GetTextOfEmptyGallery();
 257 }
 258
 259 result
 260 _Gallery::SetBitmapOfEmptyGallery(const _GalleryBitmap* pBitmap)
 261 {
 262         return GetPresenter().SetBitmapOfEmptyGallery(pBitmap);
 263 }
 264
 265 result
 266 _Gallery::SetCoreEventListener(const _IGalleryCoreEventListener& coreEventListener)
 267 {
 268         return GetPresenter().SetCoreEventListener(coreEventListener);
 269 }
 270
 271 result
 272 _Gallery::RemoveCoreEventListener(const _IGalleryCoreEventListener& coreEventListener)
 273 {
 274         return GetPresenter().RemoveCoreEventListener(coreEventListener);
 275 }
 276
 277 result
 278 _Gallery::SetZoomingEnabled(bool enable)
 279 {
 280         return GetPresenter().SetZoomingEnabled(enable);
 281 }
 282
 283 bool
 284 _Gallery::IsZoomingEnabled(void) const
 285 {
 286         return GetPresenter().IsZoomingEnabled();
 287 }
 288
 289 result
 290 _Gallery::SetSlideShowType(_GallerySlideShowType slideShowType)
 291 {
 292         return GetPresenter().SetSlideShowType(slideShowType);
 293 }
 294
 295 _GallerySlideShowType
 296 _Gallery::GetSlideShowType(void) const
 297 {
 298         return GetPresenter().GetSlideShowType();
 299 }
 300
 301 result
 302 _Gallery::SetSlideShowAnimationDuration(int duration)
 303 {
 304         return GetPresenter().SetSlideShowAnimationDuration(duration);
 305 }
 306
 307 int
 308 _Gallery::GetSlideShowAnimationDuration(void) const
 309 {
 310         return GetPresenter().GetSlideShowAnimationDuration();
 311 }
 312
 313 result
 314 _Gallery::SetSlideShowViewDuration(int duration)
 315 {
 316         return GetPresenter().SetSlideShowViewDuration(duration);
 317 }
 318
 319 int
 320 _Gallery::GetSlideShowViewDuration(void) const
 321 {
 322         return GetPresenter().GetSlideShowViewDuration();
 323 }
 324
 325 result
 326 _Gallery::StartSlideShow(bool repeat)
 327 {
 328         SetFocused(true);
 329         return GetPresenter().StartSlideShow(repeat);
 330 }
 331
 332 result
 333 _Gallery::StopSlideShow(void)
 334 {
 335         return GetPresenter().StopSlideShow();
 336 }
 337
 338 bool
 339 _Gallery::IsSlideShowStarted(void) const
 340 {
 341         return GetPresenter().IsSlideShowStarted();
 342 }
 343
 344 // model access
 345 result
 346 _Gallery::SetCurrentItemIndex(int itemIndex)
 347 {
 348         return GetPresenter().SetCurrentItem(itemIndex);
 349 }
 350
 351 int
 352 _Gallery::GetCurrentItemIndex(void) const
 353 {
 354         return GetPresenter().GetCurrentItemIndex();
 355 }
 356
 357 int
 358 _Gallery::GetItemCount(void) const
 359 {
 360         return GetPresenter().GetItemCount();
 361 }
 362
 363 result
 364 _Gallery::RequestToLoadItem(int itemIndex)
 365 {
 366         SysTryReturnResult(NID_UI_CTRL, __modelInitialized == true, E_INVALID_OPERATION, "Does not call to first draw.");
 367         result r = GetPresenter().RequestToLoadItem(itemIndex);
 368         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagation.", GetErrorMessage(r));
 369
 370         InitializeAccessibilityElement();
 371
 372         return E_SUCCESS;
 373 }
 374
 375 result
 376 _Gallery::RequestToUnloadItem(int itemIndex)
 377 {
 378         SysTryReturnResult(NID_UI_CTRL, __modelInitialized == true, E_INVALID_OPERATION, "Does not call to first draw.");
 379         result r = GetPresenter().RequestToUnloadItem(itemIndex);
 380         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagation.", GetErrorMessage(r));
 381
 382         InitializeAccessibilityElement();
 383
 384         return E_SUCCESS;
 385 }
 386
 387 result
 388 _Gallery::RequestToUnloadAllItems(void)
 389 {
 390         result r = GetPresenter().RequestToUnloadAllItems();
 391         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagation.", GetErrorMessage(r));
 392
 393         InitializeAccessibilityElement();
 394
 395         return E_SUCCESS;
 396 }
 397
 398 result
 399 _Gallery::RequestToUpdateItem(int itemIndex)
 400 {
 401         SysTryReturnResult(NID_UI_CTRL, __modelInitialized == true, E_INVALID_OPERATION, "Does not call to first draw.");
 402         result r = GetPresenter().RequestToUpdateItem(itemIndex);
 403         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagation.", GetErrorMessage(r));
 404
 405         InitializeAccessibilityElement();
 406
 407         return E_SUCCESS;
 408 }
 409
 410 result
 411 _Gallery::RequestToUpdateAllItems(void)
 412 {
 413         result r = GetPresenter().RequestToUpdateAllItems();
 414         SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagation.", GetErrorMessage(r));
 415
 416         InitializeAccessibilityElement();
 417
 418         return E_SUCCESS;
 419 }
 420
 421 bool
 422 _Gallery::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 423 {
 424         __longPressed = false;
 425         _GalleryViewEventInfo viewEventInfo;
 426         int distanceX = 0;
 427         int distanceY = 0;
 428         gesture.GetDistance(distanceX, distanceY);
 429         if (gesture.GetDirection() == _FLICK_DIRECTION_RIGHT
 430                 || gesture.GetDirection() == _FLICK_DIRECTION_LEFT)
 431         {
 432                 distanceY = 0;
 433         }
 434         else
 435         {
 436                 distanceX = 0;
 437         }
 438         Point flickPoint(distanceX, distanceY);
 439
 440         viewEventInfo.SetFlickPosition(flickPoint);
 441         viewEventInfo.SetFlicked(true);
 442         viewEventInfo.SetFlickTime(gesture.GetDuration());
 443         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_FLICK, &viewEventInfo);
 444         bool r = GetPresenter().PostEvent(viewEvent);
 445         SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 446
 447         return true;
 448 }
 449
 450 bool
 451 _Gallery::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 452 {
 453         return false;
 454 }
 455
 456 bool
 457 _Gallery::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
 458 {
 459         __longPressed = false;
 460         if (gesture.GetTapCount() == 1)
 461         {
 462                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, this);
 463         }
 464         else
 465         {
 466                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_MULTI_TAP, this);
 467                 Point pos(0, 0);
 468                 Tizen::Ui::_TouchInfo touchInfo(0, _TOUCH_DOUBLE_PRESSED, pos, false, 0);
 469                 _GalleryViewEventInfo viewEventInfo(touchInfo);
 470                 _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_DOUBLE_PRESSED, &viewEventInfo);
 471
 472                 bool r = GetPresenter().PostEvent(viewEvent);
 473                 SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 474         }
 475
 476         return true;
 477 }
 478
 479 bool
 480 _Gallery::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
 481 {
 482         return false;
 483 }
 484
 485 bool
 486 _Gallery::OnPinchGestureStarted(_TouchPinchGestureDetector& gesture)
 487 {
 488         __longPressed = false;
 489         return true;
 490 }
 491
 492 bool
 493 _Gallery::OnPinchGestureChanged(_TouchPinchGestureDetector& gesture)
 494 {
 495         _GalleryViewEventInfo viewEventInfo;
 496         viewEventInfo.SetPinchCenterPosition(_CoordinateSystemUtils::ConvertToFloat(gesture.GetCenterPoint()));
 497         viewEventInfo.SetPinchArea(gesture.GetScale());
 498         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_PINCH_ZOOM, &viewEventInfo);
 499         bool r = GetPresenter().PostEvent(viewEvent);
 500         SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 501         return true;
 502 }
 503
 504 bool
 505 _Gallery::OnPinchGestureFinished(_TouchPinchGestureDetector& gesture)
 506 {
 507         //return OnPinchGestureChanged(gesture);
 508         return true;
 509 }
 510
 511 bool
 512 _Gallery::OnPinchGestureCanceled(_TouchPinchGestureDetector& gesture)
 513 {
 514         return false;
 515 }
 516
 517 bool
 518 _Gallery::OnLongPressGestureDetected(_TouchLongPressGestureDetector& gesture)
 519 {
 520         __longPressed = true;
 521         return true;
 522 }
 523
 524 bool
 525 _Gallery::OnLongPressGestureCanceled(_TouchLongPressGestureDetector& gesture)
 526 {
 527         return true;
 528 }
 529
 530 // Touch Event Callbacks
 531 bool
 532 _Gallery::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 533 {
 534         _GalleryViewEventInfo viewEventInfo(const_cast <_TouchInfo&>(touchinfo));
 535         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_PRESSED, &viewEventInfo);
 536
 537         return GetPresenter().PostEvent(viewEvent);
 538 }
 539
 540 bool
 541 _Gallery::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 542 {
 543         _GalleryViewEventInfo viewEventInfo(const_cast <_TouchInfo&>(touchinfo));
 544         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_RELEASED, &viewEventInfo);
 545
 546         bool touchReturn = GetPresenter().PostEvent(viewEvent);
 547         if (__longPressed == true)
 548         {
 549                 PLAY_FEEDBACK(_RESOURCE_FEEDBACK_PATTERN_TAP, this);
 550                 __longPressed = false;
 551         }
 552
 553         return touchReturn;
 554 }
 555
 556 bool
 557 _Gallery::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 558 {
 559         __longPressed = false;
 560         _GalleryViewEventInfo viewEventInfo(const_cast <_TouchInfo&>(touchinfo));
 561         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_MOVED, &viewEventInfo);
 562
 563         return GetPresenter().PostEvent(viewEvent);
 564 }
 565
 566 bool
 567 _Gallery::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 568 {
 569         _GalleryViewEventInfo viewEventInfo;
 570         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_CANCELED, &viewEventInfo);
 571
 572         return GetPresenter().PostEvent(viewEvent);
 573 }
 574
 575 // Windowing Event Callbacks
 576 void
 577 _Gallery::OnDraw(void)
 578 {
 579         if (__modelInitialized == false)
 580         {
 581                 //GetPresenter().RequestToUpdateItemCount();
 582                 __modelInitialized = true;
 583         }
 584
 585         GetPresenter().OnDraw();
 586
 587         if (__keyEventProcessing == true)
 588         {
 589                 __keyEventProcessing = false;
 590         }
 591 }
 592
 593 void
 594 _Gallery::OnBoundsChanged(void)
 595 {
 596         _GalleryViewEventInfo viewEventInfo;
 597         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_BOUNDS_CHANGED, &viewEventInfo);
 598
 599         bool r = GetPresenter().PostEvent(viewEvent);
 600         SysTryReturnVoidResult(NID_UI_CTRL, r == true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 601         ResizeGalleryAccessibilityElement();
 602 }
 603
 604 void
 605 _Gallery::OnFontInfoRequested(unsigned long& style, int& size)
 606 {
 607         GetPresenter().OnFontInfoRequested(style, size);
 608 }
 609
 610 void
 611 _Gallery::OnFontChanged(Font* pFont)
 612 {
 613         GetPresenter().OnFontChanged();
 614 }
 615
 616 void
 617 _Gallery::SetEffect(Effect* pEffect)
 618 {
 619         GetRenderer().SetEffect(pEffect);
 620 }
 621
 622 Effect*
 623 _Gallery::GetEffect(void)
 624 {
 625         return GetRenderer().GetEffect();
 626 }
 627
 628 result
 629 _Gallery::OnAttachedToMainTree(void)
 630 {
 631         InitializeAccessibilityElement();
 632
 633         return E_SUCCESS;
 634 }
 635
 636 void
 637 _Gallery::InitializeAccessibilityElement(void)
 638 {
 639         if (_AccessibilityManager::IsActivated() != true)
 640         {
 641                 return;
 642         }
 643
 644         if (GetItemCount() > 0)
 645         {
 646                 AddGalleryAccessibilityElement();
 647         }
 648         else
 649         {
 650                 RemoveGalleryAccessibilityElements();
 651         }
 652
 653         return;
 654 }
 655
 656 void
 657 _Gallery::ResizeGalleryAccessibilityElement(void)
 658 {
 659         if (_AccessibilityManager::IsActivated() == true && __pGalleryImageElement != null)
 660         {
 661                 // TODO : need _AccessibilityElement::SetBoundsF()
 662                 FloatRectangle floatRect = __pRenderer->GetCanvasImageBounds(__pPresenter->SearchCanvasIndex(GetCurrentItemIndex()));
 663                 Rectangle rect(floatRect.x, floatRect.y, floatRect.width, floatRect.height);
 664                 __pGalleryImageElement->SetBounds(rect);
 665         }
 666
 667         return;
 668 }
 669
 670 void
 671 _Gallery::RemoveGalleryAccessibilityElements(void)
 672 {
 673         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 674
 675         if (pContainer != null && __pGalleryImageElement != null)
 676         {
 677                 result r = pContainer->RemoveElement(*__pGalleryImageElement);
 678                 SysTryReturnVoidResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 679                 __pGalleryImageElement = null;
 680         }
 681 }
 682
 683 void
 684 _Gallery::AddGalleryAccessibilityElement(void)
 685 {
 686         _AccessibilityContainer* pContainer = GetAccessibilityContainer();
 687         if(pContainer != null && __pGalleryImageElement == null)
 688         {
 689                 _AccessibilityElement* pGalleryElement = new (std::nothrow) _AccessibilityElement(true);
 690                 SysTryReturnVoidResult(NID_UI_CTRL, pGalleryElement, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
 691
 692                 FloatRectangle floatRect = __pRenderer->GetCanvasImageBounds(__pPresenter->SearchCanvasIndex(GetCurrentItemIndex()));
 693                 Rectangle rect(floatRect.x, floatRect.y, floatRect.width, floatRect.height);
 694                 pGalleryElement->SetBounds(rect);
 695                 pGalleryElement->SetTraitWithStringId("IDS_TPLATFORM_BODY_IMAGE");
 696                 pGalleryElement->SetName(L"GalleryImage");
 697
 698                 pContainer->AddElement(*pGalleryElement);
 699                 __pGalleryImageElement = pGalleryElement;
 700         }
 701
 702         return;
 703 }
 704
 705 void
 706 _Gallery::OnSettingChanged(Tizen::Base::String& key)
 707 {
 708         const wchar_t* LOCALE_LANGUAGE = L"http://tizen.org/setting/locale.language";
 709         if (key == LOCALE_LANGUAGE)
 710         {
 711                 __pPresenter->UpdateEmptyString();
 712         }
 713 }
 714
 715 bool
 716 _Gallery::OnKeyPressed(const _Control& source, const _KeyInfo& keyInfo)
 717 {
 718         bool returnValue = false;
 719         bool keyPressed = false;
 720
 721         if (keyInfo.GetKeyCode() == _KEY_ENTER
 722                 || keyInfo.GetKeyCode() == _KEY_UP
 723                 || keyInfo.GetKeyCode() == _KEY_DOWN
 724                 || keyInfo.GetKeyCode() == _KEY_LEFT
 725                 || keyInfo.GetKeyCode() == _KEY_RIGHT)
 726         {
 727                 if (__keyEventProcessing == true)
 728                 {
 729                         Invalidate();
 730                         return true;
 731                 }
 732
 733                 keyPressed = true;
 734                 _GalleryViewEventInfo viewEventInfo;
 735                 _GalleryViewEvent pressedEvent(GALLERY_VIEW_EVENT_TOUCH_PRESSED, &viewEventInfo);
 736                 returnValue = GetPresenter().PostEvent(pressedEvent);
 737                 SysTryReturn(NID_UI_CTRL, returnValue == true, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 738
 739                 __keyEventProcessing = true;
 740         }
 741
 742         switch (keyInfo.GetKeyCode())
 743         {
 744         case _KEY_UP:
 745         {
 746                 _GalleryViewEventInfo viewEventInfo;
 747                 Point flickPoint(0, 100);
 748                 viewEventInfo.SetFlickPosition(flickPoint);
 749                 viewEventInfo.SetFlicked(true);
 750                 viewEventInfo.SetFlickTime(1);
 751                 _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_FLICK, &viewEventInfo);
 752                 returnValue = GetPresenter().PostEvent(viewEvent);
 753                 if (returnValue == false)
 754                 {
 755                         __keyEventProcessing = false;
 756                 }
 757
 758                 break;
 759         }
 760
 761         case _KEY_DOWN:
 762         {
 763                 _GalleryViewEventInfo viewEventInfo;
 764                 Point flickPoint(0, -100);
 765                 viewEventInfo.SetFlickPosition(flickPoint);
 766                 viewEventInfo.SetFlicked(true);
 767                 viewEventInfo.SetFlickTime(1);
 768                 _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_FLICK, &viewEventInfo);
 769                 returnValue = GetPresenter().PostEvent(viewEvent);
 770                 if (returnValue == false)
 771                 {
 772                         __keyEventProcessing = false;
 773                 }
 774
 775                 break;
 776         }
 777
 778         case _KEY_LEFT:
 779         {
 780                 _GalleryViewEventInfo viewEventInfo;
 781                 Point flickPoint(100, 0);
 782                 viewEventInfo.SetFlickPosition(flickPoint);
 783                 viewEventInfo.SetFlicked(true);
 784                 viewEventInfo.SetFlickTime(1);
 785                 _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_FLICK, &viewEventInfo);
 786                 returnValue = GetPresenter().PostEvent(viewEvent);
 787                 if (returnValue == false)
 788                 {
 789                         __keyEventProcessing = false;
 790                 }
 791
 792                 break;
 793         }
 794
 795         case _KEY_RIGHT:
 796         {
 797                 _GalleryViewEventInfo viewEventInfo;
 798                 Point flickPoint(-100, 0);
 799                 viewEventInfo.SetFlickPosition(flickPoint);
 800                 viewEventInfo.SetFlicked(true);
 801                 viewEventInfo.SetFlickTime(1);
 802                 _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_FLICK, &viewEventInfo);
 803                 returnValue = GetPresenter().PostEvent(viewEvent);
 804                 if (returnValue == false)
 805                 {
 806                         __keyEventProcessing = false;
 807                 }
 808
 809                 break;
 810         }
 811
 812         default:
 813                 break;
 814         }
 815
 816         if (keyPressed == true)
 817         {
 818                 _GalleryViewEventInfo viewEventInfo;
 819                 _GalleryViewEvent releaseEvent(GALLERY_VIEW_EVENT_TOUCH_RELEASED, &viewEventInfo);
 820                 bool releaseReturnValue = GetPresenter().PostEvent(releaseEvent);
 821                 SysTryReturn(NID_UI_CTRL, releaseReturnValue == true, false, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 822         }
 823
 824         return returnValue;
 825 }
 826
 827 bool
 828 _Gallery::OnKeyReleased(const _Control& source, const _KeyInfo& keyInfo)
 829 {
 830         if ((keyInfo.GetKeyCode() == _KEY_BACK  || keyInfo.GetKeyCode() == _KEY_ESC) && IsSlideShowStarted())
 831         {
 832                 StopSlideShow();
 833                 return true;
 834         }
 835
 836         return false;
 837 }
 838
 839 }}} // Tizen::Ui::Controls