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 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 <FBaseString.h>
  18 #include <FGrpColor.h>
  19 #include "FUi_TouchFlickGestureDetector.h"
  20 #include "FUi_TouchTapGestureDetector.h"
  21 #include "FUi_TouchPinchGestureDetector.h"
  22 #include "FUiCtrl_Gallery.h"
  23 #include "FUiCtrl_GalleryBitmap.h"
  24 #include "FUiCtrl_GalleryPresenter.h"
  25 #include "FUiCtrl_GalleryRenderer.h"
  26 #include "FUiCtrl_GalleryRendererNotification.h"
  27 #include "FUiCtrl_GalleryViewEventInfo.h"
  28 #include "FUiCtrl_GalleryViewEvent.h"
  29 #include "FUiCtrl_IGalleryCoreEventListener.h"
  30 #include "FUiCtrl_IGalleryRendererNotiListener.h"
  31
  32 using namespace Tizen::Base;
  33 using namespace Tizen::Graphics;
  34 using namespace Tizen::Ui::Effects;
  35
  36 namespace Tizen { namespace Ui { namespace Controls {
  37
  38 _Gallery::_Gallery(void)
  39         : __pRenderer(null)
  40         , __pPresenter(null)
  41         , __modelInitialized(false)
  42 {
  43         // Do nothing.
  44 }
  45
  46 _Gallery::~_Gallery(void)
  47 {
  48         result r = __flickGesture.RemoveGestureListener(*this);
  49         if (r != E_SUCCESS)
  50         {
  51                 SetLastResult(r);
  52                 SysAssert(false);
  53         }
  54
  55         r = RemoveGestureDetector(__flickGesture);
  56         if (r != E_SUCCESS)
  57         {
  58                 SetLastResult(r);
  59                 SysAssert(false);
  60         }
  61
  62         r = __tapGesture.RemoveGestureListener(*this);
  63         if (r != E_SUCCESS)
  64         {
  65                 SetLastResult(r);
  66                 SysAssert(false);
  67         }
  68
  69         r = RemoveGestureDetector(__tapGesture);
  70         if (r != E_SUCCESS)
  71         {
  72                 SetLastResult(r);
  73                 SysAssert(false);
  74         }
  75
  76         r = __pinchGesture.RemoveGestureListener(*this);
  77         if (r != E_SUCCESS)
  78         {
  79                 SetLastResult(r);
  80                 SysAssert(false);
  81         }
  82
  83         r = RemoveGestureDetector(__pinchGesture);
  84         if (r != E_SUCCESS)
  85         {
  86                 SetLastResult(r);
  87                 SysAssert(false);
  88         }
  89
  90         delete __pRenderer;
  91         delete __pPresenter;
  92 }
  93
  94 _Gallery*
  95 _Gallery::CreateGalleryN(_GalleryItemProviderAdaptorImpl* pGalleryItemProviderAdaptor)
  96 {
  97         result r = E_SUCCESS;
  98         ClearLastResult();
  99
 100         _Gallery* pGallery = new (std::nothrow) _Gallery();
 101         SysTryCatch(NID_UI_CTRL, pGallery != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Failed to allocate the memory for the _Gallery.");
 102
 103         r = pGallery->Construct(pGalleryItemProviderAdaptor);
 104         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 105
 106         SetLastResult(E_SUCCESS);
 107
 108         return pGallery;
 109
 110 CATCH:
 111         delete pGallery;
 112
 113         return null;
 114 }
 115
 116 result
 117 _Gallery::Construct(_GalleryItemProviderAdaptorImpl* pGalleryItemProviderAdaptor)
 118 {
 119         result r = E_SUCCESS;
 120         _GalleryRenderer* pRenderer = null;
 121         _GalleryPresenter* pPresenter = null;
 122
 123         pRenderer = _GalleryRenderer::CreateGalleryRendererN((Tizen::Ui::_Control&)*this);
 124         SysTryCatch(NID_UI_CTRL, pRenderer != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the _GalleryRenderer.");
 125
 126         pPresenter = _GalleryPresenter::CreateGalleryPresenterN((_IGalleryRenderer&)*pRenderer, pGalleryItemProviderAdaptor);
 127         SysTryCatch(NID_UI_CTRL, pPresenter != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the _GalleryPresenter.");
 128
 129         r = pRenderer->AddNotiListener(*pPresenter);
 130         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 131
 132         AcquireHandle();
 133
 134         r = __flickGesture.AddGestureListener(*this);
 135         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 136
 137         r = _Control::AddGestureDetector(__flickGesture);
 138         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 139
 140         r = __tapGesture.AddGestureListener(*this);
 141         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 142
 143         __tapGesture.SetTapCount(2);
 144         r = _Control::AddGestureDetector(__tapGesture);
 145         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 146
 147         SetMultiTouchEnabled(true);
 148         r = _Control::AddGestureDetector(__pinchGesture);
 149         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 150
 151         r = __pinchGesture.AddGestureListener(*this);
 152         SysTryCatch(NID_UI_CTRL, r == E_SUCCESS, , r, "[%s] Propagating.", GetErrorMessage(r));
 153
 154         SetRenderer((_GalleryRenderer &)*pRenderer);
 155         SetPresenter((_GalleryPresenter &)*pPresenter);
 156
 157         return E_SUCCESS;
 158
 159 CATCH:
 160         delete pRenderer;
 161         delete pPresenter;
 162
 163         return r;
 164 }
 165
 166 // presenter access
 167 result
 168 _Gallery::SetTextOfEmptyGallery(const String& text)
 169 {
 170         return GetPresenter().SetTextOfEmptyGallery(text);
 171 }
 172
 173 String
 174 _Gallery::GetTextOfEmptyGallery(void) const
 175 {
 176         return GetPresenter().GetTextOfEmptyGallery();
 177 }
 178
 179 result
 180 _Gallery::SetBitmapOfEmptyGallery(const _GalleryBitmap* pBitmap)
 181 {
 182         return GetPresenter().SetBitmapOfEmptyGallery(pBitmap);
 183 }
 184
 185 result
 186 _Gallery::SetCoreEventListener(const _IGalleryCoreEventListener& coreEventListener)
 187 {
 188         return GetPresenter().SetCoreEventListener(coreEventListener);
 189 }
 190
 191 result
 192 _Gallery::RemoveCoreEventListener(const _IGalleryCoreEventListener& coreEventListener)
 193 {
 194         return GetPresenter().RemoveCoreEventListener(coreEventListener);
 195 }
 196
 197 result
 198 _Gallery::SetZoomingEnabled(bool enable)
 199 {
 200         return GetPresenter().SetZoomingEnabled(enable);
 201 }
 202
 203 bool
 204 _Gallery::IsZoomingEnabled(void) const
 205 {
 206         return GetPresenter().IsZoomingEnabled();
 207 }
 208
 209 result
 210 _Gallery::SetSlideShowType(_GallerySlideShowType slideShowType)
 211 {
 212         return GetPresenter().SetSlideShowType(slideShowType);
 213 }
 214
 215 _GallerySlideShowType
 216 _Gallery::GetSlideShowType(void) const
 217 {
 218         return GetPresenter().GetSlideShowType();
 219 }
 220
 221 result
 222 _Gallery::SetSlideShowAnimationDuration(int duration)
 223 {
 224         return GetPresenter().SetSlideShowAnimationDuration(duration);
 225 }
 226
 227 int
 228 _Gallery::GetSlideShowAnimationDuration(void) const
 229 {
 230         return GetPresenter().GetSlideShowAnimationDuration();
 231 }
 232
 233 result
 234 _Gallery::SetSlideShowViewDuration(int duration)
 235 {
 236         return GetPresenter().SetSlideShowViewDuration(duration);
 237 }
 238
 239 int
 240 _Gallery::GetSlideShowViewDuration(void) const
 241 {
 242         return GetPresenter().GetSlideShowViewDuration();
 243 }
 244
 245 result
 246 _Gallery::StartSlideShow(bool repeat)
 247 {
 248         return GetPresenter().StartSlideShow(repeat);
 249 }
 250
 251 result
 252 _Gallery::StopSlideShow(void)
 253 {
 254         return GetPresenter().StopSlideShow();
 255 }
 256
 257 bool
 258 _Gallery::IsSlideShowStarted(void) const
 259 {
 260         return GetPresenter().IsSlideShowStarted();
 261 }
 262
 263 // model access
 264 result
 265 _Gallery::SetCurrentItemIndex(int itemIndex)
 266 {
 267         return GetPresenter().SetCurrentItem(itemIndex);
 268 }
 269
 270 int
 271 _Gallery::GetCurrentItemIndex(void) const
 272 {
 273         return GetPresenter().GetCurrentItemIndex();
 274 }
 275
 276 int
 277 _Gallery::GetItemCount(void) const
 278 {
 279         return GetPresenter().GetItemCount();
 280 }
 281
 282 result
 283 _Gallery::RequestToLoadItem(int itemIndex)
 284 {
 285         SysTryReturnResult(NID_UI_CTRL, __modelInitialized == true, E_INVALID_OPERATION, "Does not call to first draw.");
 286         return GetPresenter().RequestToLoadItem(itemIndex);
 287 }
 288
 289 result
 290 _Gallery::RequestToUnloadItem(int itemIndex)
 291 {
 292         SysTryReturnResult(NID_UI_CTRL, __modelInitialized == true, E_INVALID_OPERATION, "Does not call to first draw.");
 293         return GetPresenter().RequestToUnloadItem(itemIndex);
 294 }
 295
 296 result
 297 _Gallery::RequestToUnloadAllItems(void)
 298 {
 299         return GetPresenter().RequestToUnloadAllItems();
 300 }
 301
 302 result
 303 _Gallery::RequestToUpdateItem(int itemIndex)
 304 {
 305         SysTryReturnResult(NID_UI_CTRL, __modelInitialized == true, E_INVALID_OPERATION, "Does not call to first draw.");
 306         return GetPresenter().RequestToUpdateItem(itemIndex);
 307 }
 308
 309 result
 310 _Gallery::RequestToUpdateAllItems(void)
 311 {
 312         return GetPresenter().RequestToUpdateAllItems();
 313 }
 314
 315 bool
 316 _Gallery::OnFlickGestureDetected(_TouchFlickGestureDetector& gesture)
 317 {
 318         _GalleryViewEventInfo viewEventInfo;
 319         int distanceX = 0;
 320         int distanceY = 0;
 321         gesture.GetDistance(distanceX, distanceY);
 322         Point flickPoint(distanceX, distanceY);
 323
 324         viewEventInfo.SetFlickPosition(flickPoint);
 325         viewEventInfo.SetFlicked(true);
 326         viewEventInfo.SetFlickTime(gesture.GetDuration());
 327         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_FLICK, &viewEventInfo);
 328         bool r = GetPresenter().PostEvent(viewEvent);
 329         SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 330
 331         return true;
 332 }
 333
 334 bool
 335 _Gallery::OnFlickGestureCanceled(_TouchFlickGestureDetector& gesture)
 336 {
 337         return false;
 338 }
 339
 340 bool
 341 _Gallery::OnTapGestureDetected(_TouchTapGestureDetector& gesture)
 342 {
 343         Point pos(0, 0);
 344         Tizen::Ui::_TouchInfo touchInfo(0, _TOUCH_DOUBLE_PRESSED, pos, false, 0);
 345         _GalleryViewEventInfo viewEventInfo(touchInfo);
 346         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_DOUBLE_PRESSED, &viewEventInfo);
 347
 348         bool r = GetPresenter().PostEvent(viewEvent);
 349         SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 350
 351         return true;
 352 }
 353
 354 bool
 355 _Gallery::OnTapGestureCanceled(_TouchTapGestureDetector& gesture)
 356 {
 357         return false;
 358 }
 359
 360 bool
 361 _Gallery::OnPinchGestureStarted(_TouchPinchGestureDetector& gesture)
 362 {
 363         //return OnPinchGestureChanged(gesture);
 364         return true;
 365 }
 366
 367 bool
 368 _Gallery::OnPinchGestureChanged(_TouchPinchGestureDetector& gesture)
 369 {
 370         _GalleryViewEventInfo viewEventInfo;
 371         viewEventInfo.SetPinchCenterPosition(gesture.GetCenterPoint());
 372         viewEventInfo.SetPinchArea(gesture.GetScale());
 373         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_PINCH_ZOOM, &viewEventInfo);
 374         bool r = GetPresenter().PostEvent(viewEvent);
 375         SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 376         return true;
 377 }
 378
 379 bool
 380 _Gallery::OnPinchGestureFinished(_TouchPinchGestureDetector& gesture)
 381 {
 382         //return OnPinchGestureChanged(gesture);
 383         return true;
 384 }
 385
 386 bool
 387 _Gallery::OnPinchGestureCanceled(_TouchPinchGestureDetector& gesture)
 388 {
 389         return false;
 390 }
 391
 392 // Touch Event Callbacks
 393 bool
 394 _Gallery::OnTouchPressed(const _Control& source, const _TouchInfo& touchinfo)
 395 {
 396         _GalleryViewEventInfo viewEventInfo(const_cast <_TouchInfo&>(touchinfo));
 397         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_PRESSED, &viewEventInfo);
 398
 399         return GetPresenter().PostEvent(viewEvent);
 400 }
 401
 402 bool
 403 _Gallery::OnTouchReleased(const _Control& source, const _TouchInfo& touchinfo)
 404 {
 405         _GalleryViewEventInfo viewEventInfo(const_cast <_TouchInfo&>(touchinfo));
 406         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_RELEASED, &viewEventInfo);
 407
 408         return GetPresenter().PostEvent(viewEvent);
 409 }
 410
 411 bool
 412 _Gallery::OnTouchMoved(const _Control& source, const _TouchInfo& touchinfo)
 413 {
 414         _GalleryViewEventInfo viewEventInfo(const_cast <_TouchInfo&>(touchinfo));
 415         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_TOUCH_MOVED, &viewEventInfo);
 416
 417         bool r = GetPresenter().PostEvent(viewEvent);
 418         SysTryReturn(NID_UI_CTRL, r == true, true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(r));
 419
 420         SetLastResult(E_SUCCESS);
 421
 422         return true;
 423 }
 424
 425 bool
 426 _Gallery::OnTouchCanceled(const _Control& source, const _TouchInfo& touchinfo)
 427 {
 428         return true;
 429 }
 430
 431 // Windowing Event Callbacks
 432 void
 433 _Gallery::OnDraw(void)
 434 {
 435         if (__modelInitialized == false)
 436         {
 437                 //GetPresenter().RequestToUpdateItemCount();
 438                 __modelInitialized = true;
 439         }
 440
 441         GetPresenter().OnDraw();
 442 }
 443
 444 void
 445 _Gallery::OnBoundsChanged(void)
 446 {
 447 //      GetRenderer().OnBoundsChanged();
 448         _GalleryViewEventInfo viewEventInfo;
 449         _GalleryViewEvent viewEvent(GALLERY_VIEW_EVENT_BOUNDS_CHANGED, &viewEventInfo);
 450
 451         bool r = GetPresenter().PostEvent(viewEvent);
 452         SysTryReturnVoidResult(NID_UI_CTRL, r == true, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));
 453 }
 454
 455 void
 456 _Gallery::OnFontInfoRequested(unsigned long& style, int& size)
 457 {
 458         GetPresenter().OnFontInfoRequested(style, size);
 459 }
 460
 461 void
 462 _Gallery::OnFontChanged(Font* pFont)
 463 {
 464         GetPresenter().OnFontChanged();
 465 }
 466
 467 void
 468 _Gallery::SetEffect(Effect* pEffect)
 469 {
 470         GetRenderer().SetEffect(pEffect);
 471 }
 472
 473 Effect*
 474 _Gallery::GetEffect(void)
 475 {
 476         return GetRenderer().GetEffect();
 477 }
 478
 479 }}} // Tizen::Ui::Controls