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