dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.h

   1 #ifndef __DALI_TOOLKIT_INTERNAL_PAGE_TURN_VIEW_IMPL_H__
   2 #define __DALI_TOOLKIT_INTERNAL_PAGE_TURN_VIEW_IMPL_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/actors/layer.h>
  23 #include <dali/public-api/actors/camera-actor.h>
  24 #include <dali/public-api/common/map-wrapper.h>
  25 #include <dali/public-api/images/frame-buffer-image.h>
  26 #include <dali/public-api/render-tasks/render-task.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/public-api/controls/control-impl.h>
  30 #include <dali-toolkit/public-api/controls/page-turn-view/page-turn-view.h>
  31 #include <dali-toolkit/internal/shader-effects/page-turn-effect-impl.h>
  32 #include <dali-toolkit/public-api/shader-effects/page-turn-effect.h>
  33 #include <dali-toolkit/public-api/shader-effects/page-turn-book-spine-effect.h>
  34 #include <dali-toolkit/public-api/controls/page-turn-view/page-factory.h>
  35 #include <dali-toolkit/public-api/controls/shadow-view/shadow-view.h>
  36
  37 namespace Dali
  38 {
  39
  40 namespace Toolkit
  41 {
  42
  43 namespace Internal
  44 {
  45
  46 class PageTurnView : public Control
  47 {
  48 protected:
  49
  50   /**
  51    * Constructor.
  52    * It initializes the PageTurnView members
  53    */
  54   PageTurnView( PageFactory& pageFactory, const Vector2& pageSize );
  55
  56   /**
  57    * A reference counted object may only be deleted by calling Unreference()
  58    */
  59   virtual ~PageTurnView();
  60
  61 public:
  62
  63   /**
  64    * @copydoc Toolkit::PageTurnView::SetSpineShadowParameter
  65    */
  66   void SetSpineShadowParameter( const Vector2& spineShadowParameter );
  67
  68   /**
  69    * @copydoc Toolkit::PageTurnView::GetSpineShadowParameter
  70    */
  71   Vector2 GetSpineShadowParameter();
  72
  73   /**
  74    * @copydoc Toolkit::PageTurnView::GoToPage
  75    */
  76   void GoToPage( unsigned int pageId );
  77
  78   /**
  79    * @copydoc Toolkit::PageTurnView::GetCurrentPage
  80    */
  81   unsigned int GetCurrentPage();
  82
  83   /**
  84    * @copydoc Toolkit::PageTurnView::EnterEditMode
  85    */
  86   Actor EnterEditMode();
  87
  88   /**
  89    * @copydoc Toolkit::PageTurnView::LeaveEditMode
  90    */
  91   void LeaveEditMode();
  92
  93   /**
  94    * @copydoc Toolkit::PageTurnView::GetHitActor
  95    */
  96   Actor GetHitActor( Vector2& screenCoordinates, Vector2& actorCoordinates );
  97
  98   /**
  99    * @copydoc Toolkit::PageTurnView::RefreshAll
 100    */
 101   void RefreshAll();
 102
 103   /**
 104    * @copydoc Toolkit::PageTurnView::RefreshCurrentPage
 105    */
 106   void RefreshCurrentPage();
 107
 108 protected:
 109
 110   /**
 111    * This method gets a page from the factory and add to the control
 112    * to keep NUMBER_OF_CACHED_PAGES_EACH_SIDE pages available in each side
 113    * @param[in] pageIndex The index of the page to be added
 114    */
 115   void AddPage( int pageIndex );
 116
 117   /**
 118    * This method removes a page from the control
 119    * to keep only NUMBER_OF_CACHED_PAGES_EACH_SIDE pages available in each side
 120    * @param[in] pageIndex The index of the page to be removed
 121    */
 122   void RemovePage( int pageIndex );
 123
 124   /**
 125    * This method updates the actor and animation states after one page is turned over
 126    * This method is a callback, connected when receiving the finished signal of a page turning over animation.
 127    * @param [in] the page turning over animation handle
 128    */
 129   void TurnedOver( Animation& animation );
 130
 131   /**
 132    * This method organize the depth of the pages on stage
 133    * It is called when there is page added or removed from the control
 134    */
 135   void OrganizePageDepth();
 136
 137   /**
 138    * Set shader Effect to the actor.
 139    * If the actor has children, the shader effect is also applied to its first child
 140    * @param[in] actor The actor which the shader effect would be applied onto
 141    * @param[in] shaderEffect The shader effect to be set to the actor
 142    */
 143   void SetShaderEffect( ImageActor actor, ShaderEffect shaderEffect );
 144
 145 private:
 146
 147   /**
 148    * Set up the render tasks for rendering the page actor to off-screen image
 149    */
 150   void SetupRenderTasks();
 151
 152  /**
 153   * Set up the shadow view control to cast shadow
 154   */
 155   void SetupShadowView();
 156
 157   /**
 158    * This method defines the processes when the pan started, gets called by OnPan( .. )
 159    * @param[in] gesturePosition The current touch position in local page actor coordinates.
 160    */
 161   void PanStarted( const Vector2& gesturePosition );
 162
 163   /**
 164    * This method defines the processes when the pan continuing, gets called by OnPan( .. )
 165    * @param[in] gesturePosition The current touch position in local page actor coordinates.
 166    */
 167   void PanContinuing( const Vector2& gesturePosition );
 168
 169   /**
 170    * This method defines the processes when the pan finished, gets called by OnPanGesture( .. )
 171    * @param[in] gesturePosition The current touch position in local page actor coordinates.
 172    * @param[in] gestureSpeed The speed of the pan ( in pixels per millisecond )
 173    */
 174   void PanFinished( const Vector2& gesturePosition, float gestureSpeed );
 175
 176   /**
 177    * This method updates the actor and the animation states after one page is slidden back instead of turned over
 178    * This method is a callback, connected when receiving the finished signal of a page sliding back animation.
 179    * @param [in] the page sliding back animation handle
 180    */
 181   void SliddenBack( Animation& animation );
 182
 183   /**
 184    * Refresh the given page.
 185    @param[in] the page index.
 186    */
 187   void RenderPage( int pageIndex );
 188
 189 private: // from Control
 190
 191   /**
 192    * @copydoc Toolkit::Control::OnPan
 193    */
 194   virtual void OnPan( const PanGesture& gesture );
 195
 196   /**
 197    * @copydoc Toolkit::Control::OnInitialize
 198    */
 199   virtual void OnInitialize();
 200
 201   /**
 202    * @copydoc Toolkit::Control::OnControlStageConncection
 203    */
 204   virtual void OnControlStageConnection();
 205
 206   /**
 207    * @copydoc Toolkit::Control::OnControlStageDisConnection
 208    */
 209   virtual void OnControlStageDisconnection();
 210
 211   /**
 212    * @copydoc Toolkit::Control::OnControlSizeSet
 213    */
 214   virtual void OnControlSizeSet( const Vector3& size );
 215
 216 private: // implemented differently by PageTurnLandscapeView and PageTurnPortraitView
 217
 218   /**
 219    * This method is called after the pageTurnView initialization.
 220    * To set the size of the control size and the parent origin of turning page layer
 221    * Implemented in subclasses to provide specific behaviour.
 222    */
 223   virtual void OnPageTurnViewInitialize() = 0;
 224
 225   /**
 226    * Create the page actor from off screen buffer
 227    * @param[in] The index of the page to be added
 228    */
 229   virtual ImageActor NewPageFromRenderBuffer( int pageIndex ) = 0;
 230
 231   /**
 232    * This method is called after the a new page is added to the stage.
 233    * Could be re-implemented in subclasses to provide specific behaviour
 234    * @param[in] newPage The added page actor
 235    * @param[in] isLeftSide Which side the new page is added to
 236    */
 237   virtual void OnAddPage( ImageActor newPage, bool isLeftSide ) { }
 238
 239   /**
 240    * This method is called when pan started or continuing
 241    * to calculate the pan position in local page actor coordinate given the pan position in control coordinate
 242    * Implemented in subclasses to provide specific behaviour.
 243    * @param[in] gesturePosition The pan position in the control coordinate
 244    * @return The pan position in the page actor local coordinate
 245    */
 246   virtual Vector2 SetPanPosition( const Vector2& gesturePosition ) = 0;
 247
 248   /**
 249    * This method is called when pan started to determined which page is panned given the pan position in control coordinate
 250    * Implemented in subclasses to provide specific behaviour.
 251    * @param[in] gesturePosition The pan position in the control coordinate
 252    */
 253   virtual void SetPanActor( const Vector2& panPosition ) = 0;
 254
 255   /**
 256    * This method is called when a page is turned over or slidden back
 257    * Remove PageTurnEffect and use a proper PageTurnBookSpineEffect
 258    * Implemented in subclasses to provide specific behaviour.
 259    * @param[in] actor The current page actor
 260    * @param[in] isLeftSide Which side the current page is located
 261    */
 262   virtual void SetSpineEffect(ImageActor actor, bool isLeftSide) = 0;
 263
 264   /**
 265    * This method is called when pan finished to detect outwards flick
 266    * In portrait view, start an animation of turning previous page back when outwards flick is detected
 267    * In landscape view, nothing to do
 268    * @param[in] panPosition The pan position in the page actor local coordinate
 269    * @param[in] gestureSpeed The speed of the pan gesture( in pixels per millisecond )
 270    */
 271   virtual void OnPossibleOutwardsFlick( const Vector2& panPosition, float gestureSpeed ) { }
 272
 273 public: //signal
 274
 275   /**
 276    * @copydoc Toolkit::PageTurnView::PageTurnStartedSignal()
 277    */
 278   Toolkit::PageTurnView::PageTurnSignal& PageTurnStartedSignal();
 279
 280   /**
 281    * @copydoc Toolkit::PageTurnView::PageTurnFinishedSignal()
 282    */
 283   Toolkit::PageTurnView::PageTurnSignal& PageTurnFinishedSignal();
 284
 285   /**
 286    * @copydoc Toolkit::PageTurnView::PagePanStartSignal()
 287    */
 288   Toolkit::PageTurnView::PagePanSignal& PagePanStartedSignal();
 289
 290   /**
 291    * @copydoc Toolkit::PageTurnView::PagePanFinishedSignal()
 292    */
 293   Toolkit::PageTurnView::PagePanSignal& PagePanFinishedSignal();
 294
 295 private:
 296
 297   //Undefined
 298   PageTurnView( const PageTurnView& );
 299
 300   //undefined
 301   PageTurnView& operator=(const PageTurnView& rhs);
 302
 303 protected:
 304
 305   Actor                          mRootOnScreen;
 306
 307   Vector2                        mControlSize;             ///< The size of the control, it is decided by the page size, the SetSize from application can not change it
 308   Layer                          mTurningPageLayer;        ///< The layer for the turning page, to avoid possible depth conflict
 309   Toolkit::ShadowView            mShadowView;              ///< The shadow view control for shadow casting
 310   ImageActor                     mShadowPlane;             ///< The plane for the shadow to cast on
 311   Actor                          mPointLight;              ///< The point light used for shadow casting
 312   Layer                          mShadowLayer;             ///< The layer to display the shadow
 313
 314   PageFactory&                   mPageFactory;             ///< The page factory which provides the page actors
 315   Vector2                        mPageSize;                ///< The page size
 316   int                            mTotalPageCount;          ///< The total number of pages provided by the page factory
 317
 318   bool                           mIsEditMode;              ///< The boolean to indicate the current page content is edit-able or not
 319
 320   bool                           mNeedOffscreenRendering;  ///< The boolean to indicate whether off screen rendering is required for creating page image
 321   std::vector<RenderTask>        mOffscreenTask;           ///< The vector of off screen rendering tasks
 322   std::vector<Actor>             mPageSourceActor;         ///< The vector of page source actor
 323   std::vector<FrameBufferImage>  mRenderedPage;            ///< The vector of off screen buffers
 324   CameraActor                    mCameraActor;             ///< The camera actor attached to the off screen tasks
 325   bool                           mPanning;                 ///< The boolean to indicate whether the pan gesture is continuing
 326
 327   std::vector<Toolkit::PageTurnEffect>    mTurnEffect;     ///< The group of PageTurnEffects
 328   PageTurnBookSpineEffect        mSpineEffectFront;        ///< The book spine shader effect without flipping image content
 329   PageTurnBookSpineEffect        mSpineEffectBack;         ///< The book spine shader effect with image content flipped
 330   Vector2                        mSpineShadowParameter;    ///< The spine shadow parameter for all the above shader effects
 331   Vector2                        mOriginalCenter;          ///< The original center set to the PageTurnEffect
 332   Vector2                        mCurrentCenter;           ///< The current center set to the PageTurnEffect
 333
 334   std::vector<ImageActor>        mPageActors;              ///< The vector of pages on stage
 335   int                            mCurrentPageIndex;        ///< The index of the current page, between 0 ~ mTotalPageCount-1
 336   std::map<ImageActor,bool>      mIsTurnBack;              ///< The map to keep track the page actor's turning direction
 337   std::map<Animation,ImageActor> mAnimationActorPair;      ///< The map to keep track which page actor is the animation act on
 338   std::map<Animation, int>       mAnimationIndexPair;      ///< The map to keep track which PageTurnEffect, PanDisplacementProperty, CurrentCenterProperty is used for the animation
 339   int                            mIndex;                   ///< The index to keep track which PageTurnEffect, PanDisplacementProperty, CurrentCenterProperty is used for the current panning page
 340   std::vector<bool>              mIsAnimating;             ///< The boolean vector to keep track which PageTurnEffect, PanDisplacementProperty, CurrentCenterProperty is available for using
 341   std::vector<bool>              mIsSliding;               ///< The boolean vector to keep track whether there are animating pages sliding back
 342
 343   ImageActor                     mPanActor;                ///< The page being panned by the pan gesture
 344   Vector2                        mPressDownPosition;       ///< The first press down position of the pan gesture
 345   bool                           mPress;                   ///< The boolean to keep track the state of the pageTurnEffect is activated or not
 346   bool                           mPageUpdated;             ///< The boolean to keep track whether is page is updated after any turning activity
 347
 348   float                          mDistanceUpCorner;        ///< The distance between the original center of PageTurnEffect and the top-left corner of the page
 349   float                          mDistanceBottomCorner;    ///< The distance between the original center of PageTurnEffect and the bottom-left corner of the page
 350
 351   std::vector<Property::Index>   mPropertyPanDisplacement; ///< The pan displacement property group
 352   std::vector<Property::Index>   mPropertyCurrentCenter;   ///< The current center property group
 353   float                          mPanDisplacement;         ///< The displacement of the pan after the constrains are applied
 354   bool                           mConstraints;             ///< The boolean to keep track the constrains are applied or not
 355
 356   Toolkit::PageTurnView::PageTurnSignal   mPageTurnStartedSignal;   ///< The signal to notify that a page has started turning
 357   Toolkit::PageTurnView::PageTurnSignal   mPageTurnFinishedSignal;  ///< The signal to notify that a page has finished turning
 358   Toolkit::PageTurnView::PagePanSignal    mPagePanStartedSignal;    ///< The signal to notify that a page has started panning
 359   Toolkit::PageTurnView::PagePanSignal    mPagePanFinishedSignal;   ///< The signal to notify that a page has finished panning
 360
 361   static const int               MAXIMUM_TURNING_NUM;                  ///< How many pages are allowed to animating in the same time
 362   static const int               NUMBER_OF_CACHED_PAGES_EACH_SIDE;     ///< The maximum number of pages kept, (MAXIMUM_ANIMATION_NUM+1) pages for each side
 363   static const int               NUMBER_OF_CACHED_PAGES;               ///< The maximum number of pages kept, (MAXIMUM_ANIMATION_NUM+1)*2 pages in total
 364   static const float             STATIC_PAGE_INTERVAL_DISTANCE;        ///< The depth interval between stacked pages (static pages)
 365 };
 366
 367 } // namespace Internal
 368
 369
 370 // Helpers for public-api forwarding methods
 371
 372 inline Toolkit::Internal::PageTurnView& GetImplementation(Toolkit::PageTurnView& pub)
 373 {
 374   DALI_ASSERT_ALWAYS(pub);
 375
 376   Dali::RefObject& handle = pub.GetImplementation();
 377
 378   return static_cast<Toolkit::Internal::PageTurnView&>(handle);
 379 }
 380
 381 inline const Toolkit::Internal::PageTurnView& GetImplementation(const Toolkit::PageTurnView& pub)
 382 {
 383   DALI_ASSERT_ALWAYS(pub);
 384
 385   const Dali::RefObject& handle = pub.GetImplementation();
 386
 387   return static_cast<const Toolkit::Internal::PageTurnView&>(handle);
 388 }
 389
 390 } // namespace Toolkit
 391
 392 } // namespace Dali
 393 #endif /* __DALI_TOOLKIT_INTERNAL_PAGE_TURN_VIEW_IMPL_H__ */