[dali_2.0.26] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / 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) 2021 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/rendering/renderer.h>
25
26 // INTERNAL INCLUDES
27 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
28 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
29 #include <dali-toolkit/devel-api/controls/shadow-view/shadow-view.h>
30 #include <dali-toolkit/public-api/controls/control-impl.h>
31
32 namespace Dali
33 {
34 namespace Toolkit
35 {
36 namespace Internal
37 {
38 class PageTurnView : public Control
39 {
40 protected:
41   /**
42    * The book page class
43    */
44   struct Page
45   {
46     /**
47      * Constructor
48      */
49     Page();
50     /**
51      * Destructor
52      */
53     ~Page(){};
54
55     /**
56      * Set the page texture content
57      * @param[in] texture The content of the page.
58      */
59     void SetTexture(Texture texture);
60
61     /**
62      * Apply an effect onto the page actor.
63      * @param[in] newShader The shader for rendering effect.
64      */
65     void UseEffect(Shader newShader);
66
67     /**
68      * Apply an effect onto the page actor.
69      * @param[in] newShader The shader for rendering effect.
70      * @param[in] geometry The geometry for rendering effect.
71      */
72     void UseEffect(Shader newShader, Geometry geometry);
73
74     /**
75      * Change the page turning direction.
76      */
77     void ChangeTurnDirection();
78
79     /**
80      * Set the pan displacement property
81      * @param[in] value The property value
82      */
83     void SetPanDisplacement(float value);
84
85     /**
86      * Set the pan center property
87      * @param[in] value The property value
88      */
89     void SetPanCenter(const Vector2& value);
90
91     /**
92      * Set the original center property to be used by shader
93      * @param[in] value The property value
94      */
95     void SetOriginalCenter(const Vector2& value);
96
97     /**
98      * Set the current center property to be used by shader
99      * @param[in] value The property value
100      */
101     void SetCurrentCenter(const Vector2& value);
102
103     Actor           actor;                   ///< The page actor
104     Shader          shader;                  ///< The shader used by the actor
105     TextureSet      textureSet;              ///< The set of textures used by the actor
106     Renderer        renderer;                ///< The renderer of the actor
107     bool            isTurnBack;              ///< The turning direction
108     Property::Index propertyPanDisplacement; ///< The horizontal displacement of the pan
109     Property::Index propertyPanCenter;       ///< The current pan position
110     Property::Index propertyOriginalCenter;  ///< The original center to be used by the shader
111     Property::Index propertyCurrentCenter;   ///< The current center to be used by the shader
112     Property::Index propertyTurnDirection;   ///< The turning direction property
113   };
114
115 protected:
116   /**
117    * Constructor.
118    * It initializes the PageTurnView members
119    */
120   PageTurnView(PageFactory& pageFactory, const Vector2& viewPageSize);
121
122   /**
123    * A reference counted object may only be deleted by calling Unreference()
124    */
125   virtual ~PageTurnView();
126
127 public:
128   /**
129    * Set the page size
130    * @param[in] viewPageSize The size of pages
131    */
132   void SetPageSize(const Vector2& viewPageSize);
133
134   /**
135    * Retrieve the page size.
136    * @return The page size.
137    */
138   Vector2 GetPageSize();
139
140   /**
141    * Set the spine shadow parameter to the shader effects.
142    * The two parameters are the major&minor radius (in pixels) to form an ellipse shape.
143    * The top-left quarter of this ellipse is used to calculate spine normal for simulating shadow.
144    * @param [in] spineShadowParameter The major&minor ellipse radius for the simulated spine shadow.
145    */
146   void SetSpineShadowParameter(const Vector2& spineShadowParameter);
147
148   /**
149    * Retrieve the spine shadow parameter of the shader effects.
150    * @return The spine shadow parameter.
151    */
152   Vector2 GetSpineShadowParameter();
153
154   /*
155    * Jump to a given page.
156    * @param[in] pageId The new current page id.
157    */
158   void GoToPage(unsigned int pageId);
159
160   /**
161    * Retrieve the id of the current Page.
162    * @return The current page id.
163    */
164   unsigned int GetCurrentPage();
165
166 protected:
167   /**
168    * This method gets a page from the factory and add to the control
169    * to keep NUMBER_OF_CACHED_PAGES_EACH_SIDE pages available in each side
170    * @param[in] pageIndex The index of the page to be added
171    */
172   void AddPage(int pageIndex);
173
174   /**
175    * This method removes a page from the control
176    * to keep only NUMBER_OF_CACHED_PAGES_EACH_SIDE pages available in each side
177    * @param[in] pageIndex The index of the page to be removed
178    */
179   void RemovePage(int pageIndex);
180
181   /**
182    * This method updates the actor and animation states after one page is turned over
183    * This method is a callback, connected when receiving the finished signal of a page turning over animation.
184    * @param [in] the page turning over animation handle
185    */
186   void TurnedOver(Animation& animation);
187
188   /**
189    * This method organize the depth of the pages on stage
190    * It is called when there is page added or removed from the control
191    */
192   void OrganizePageDepth();
193
194 private:
195   /**
196    * Create shader from a property map.
197    * @param[in] shaderMap The shader property map;
198    * @return The created shader.
199    */
200   Shader CreateShader(const Property::Map& shaderMap);
201
202   /**
203   * Set up the shadow view control to cast shadow
204   */
205   void SetupShadowView();
206
207   /**
208    * This method defines the processes when the pan started, gets called by OnPan( .. )
209    * @param[in] gesturePosition The current touch position in local page actor coordinates.
210    */
211   void PanStarted(const Vector2& gesturePosition);
212
213   /**
214    * This method defines the processes when the pan continuing, gets called by OnPan( .. )
215    * @param[in] gesturePosition The current touch position in local page actor coordinates.
216    */
217   void PanContinuing(const Vector2& gesturePosition);
218
219   /**
220    * This method defines the processes when the pan finished, gets called by OnPanGesture( .. )
221    * @param[in] gesturePosition The current touch position in local page actor coordinates.
222    * @param[in] gestureSpeed The speed of the pan ( in pixels per millisecond )
223    */
224   void PanFinished(const Vector2& gesturePosition, float gestureSpeed);
225
226   /**
227    * This method updates the actor and the animation states after one page is slidden back instead of turned over
228    * This method is a callback, connected when receiving the finished signal of a page sliding back animation.
229    * @param [in] the page sliding back animation handle
230    */
231   void SliddenBack(Animation& animation);
232
233   /**
234    * Stop the page turning animation and contraint.
235    * This method should be called when taking off stage or jump to a specified page.
236    */
237   void StopTurning();
238
239 private: // from Control
240   /**
241    * @copydoc Toolkit::Control::OnPan
242    */
243   void OnPan(const PanGesture& gesture) override;
244
245   /**
246    * @copydoc Toolkit::Control::OnInitialize
247    */
248   void OnInitialize() override;
249
250   /**
251    * @copydoc CustomActorImpl::OnSceneConnection()
252    */
253   void OnSceneConnection(int depth) override;
254
255   /**
256    * @copydoc CustomActorImpl::OnSceneDisconnection()
257    */
258   void OnSceneDisconnection() override;
259
260 private: // implemented differently by PageTurnLandscapeView and PageTurnPortraitView
261   /**
262    * This method is called after the pageTurnView initialization.
263    * To set the size of the control size and the parent origin of turning page layer
264    * Implemented in subclasses to provide specific behaviour.
265    */
266   virtual void OnPageTurnViewInitialize() = 0;
267
268   /**
269    * This method is called after the a new page is added to the stage.
270    * Could be re-implemented in subclasses to provide specific behaviour
271    * @param[in] newPage The added page actor
272    * @param[in] isLeftSide Which side the new page is added to
273    */
274   virtual void OnAddPage(Actor newPage, bool isLeftSide)
275   {
276   }
277
278   /**
279    * This method is called when pan started or continuing
280    * to calculate the pan position in local page actor coordinate given the pan position in control coordinate
281    * Implemented in subclasses to provide specific behaviour.
282    * @param[in] gesturePosition The pan position in the control coordinate
283    * @return The pan position in the page actor local coordinate
284    */
285   virtual Vector2 SetPanPosition(const Vector2& gesturePosition) = 0;
286
287   /**
288    * This method is called when pan started to determined which page is panned given the pan position in control coordinate
289    * Implemented in subclasses to provide specific behaviour.
290    * @param[in] gesturePosition The pan position in the control coordinate
291    */
292   virtual void SetPanActor(const Vector2& panPosition) = 0;
293
294   /**
295    * This method is called when pan finished to detect outwards flick
296    * In portrait view, start an animation of turning previous page back when outwards flick is detected
297    * In landscape view, nothing to do
298    * @param[in] panPosition The pan position in the page actor local coordinate
299    * @param[in] gestureSpeed The speed of the pan gesture( in pixels per millisecond )
300    */
301   virtual void OnPossibleOutwardsFlick(const Vector2& panPosition, float gestureSpeed)
302   {
303   }
304
305   /**
306    * This method is called when page is turned over
307    * In portrait view, the page on the left side is not rendered
308    * @param[in] actor The page actor
309    * @param[in] isLeftSide Which side the page is turned to
310    */
311   virtual void OnTurnedOver(Actor actor, bool isLeftSide)
312   {
313   }
314
315 public: //signal and property
316   /**
317    * @copydoc Toolkit::PageTurnView::PageTurnStartedSignal()
318    */
319   Toolkit::PageTurnView::PageTurnSignal& PageTurnStartedSignal();
320
321   /**
322    * @copydoc Toolkit::PageTurnView::PageTurnFinishedSignal()
323    */
324   Toolkit::PageTurnView::PageTurnSignal& PageTurnFinishedSignal();
325
326   /**
327    * @copydoc Toolkit::PageTurnView::PagePanStartSignal()
328    */
329   Toolkit::PageTurnView::PagePanSignal& PagePanStartedSignal();
330
331   /**
332    * @copydoc Toolkit::PageTurnView::PagePanFinishedSignal()
333    */
334   Toolkit::PageTurnView::PagePanSignal& PagePanFinishedSignal();
335
336   /**
337     * Connects a callback function with the object's signals.
338     * @param[in] object The object providing the signal.
339     * @param[in] tracker Used to disconnect the signal.
340     * @param[in] signalName The signal to connect to.
341     * @param[in] functor A newly allocated FunctorDelegate.
342     * @return True if the signal was connected.
343     * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
344     */
345   static bool DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor);
346
347   // Properties
348
349   /**
350    * Called when a property of an object of this type is set.
351    * @param[in] object The object whose property is set.
352    * @param[in] index The property index.
353    * @param[in] value The new property value.
354    */
355   static void SetProperty(BaseObject* object, Property::Index index, const Property::Value& value);
356
357   /**
358    * Called to retrieve a property of an object of this type.
359    * @param[in] object The object whose property is to be retrieved.
360    * @param[in] index The property index.
361    * @return The current value of the property.
362    */
363   static Property::Value GetProperty(BaseObject* object, Property::Index index);
364
365 private:
366   //Undefined
367   PageTurnView(const PageTurnView&);
368
369   //undefined
370   PageTurnView& operator=(const PageTurnView& rhs);
371
372 protected:
373   Layer               mTurningPageLayer;      ///< The layer for the turning page, to avoid possible depth conflict
374   Toolkit::ShadowView mShadowView;            ///< The shadow view control for shadow casting
375   Actor               mShadowPlaneBackground; ///< The plane for the shadow to cast on
376   Actor               mPointLight;            ///< The point light used for shadow casting
377
378   PageFactory* const mPageFactory;       ///< The factory which provides the page actors
379   Shader             mTurnEffectShader;  ///< The group of PageTurnEffects
380   Shader             mSpineEffectShader; ///< The book spine shader effect
381   Geometry           mGeometry;          ///< The grid geometry for pages
382
383   std::vector<Page>        mPages;               ///< The vector of pages on stage
384   std::map<Animation, int> mAnimationPageIdPair; ///< The map to keep track which page actor is the animation act on
385
386   Vector2 mPageSize;             ///< The page size
387   Vector2 mControlSize;          ///< The size of the control, it is decided by the page size, the SetSize from application can not change it
388   Vector2 mSpineShadowParameter; ///< The spine shadow parameter for all the above shader effects
389   Vector2 mOriginalCenter;       ///< The original center set to the PageTurnEffect
390   Vector2 mCurrentCenter;        ///< The current center set to the PageTurnEffect
391   Vector2 mPressDownPosition;    ///< The first press down position of the pan gesture
392
393   float mDistanceUpCorner;     ///< The distance between the original center of PageTurnEffect and the top-left corner of the page
394   float mDistanceBottomCorner; ///< The distance between the original center of PageTurnEffect and the bottom-left corner of the page
395   float mPanDisplacement;      ///< The displacement of the pan after the constrains are applied
396
397   int mTotalPageCount;   ///< The total number of pages provided by the page factory
398   int mCurrentPageIndex; ///< The index of the current page, between 0 ~ mTotalPageCount-1
399   int mTurningPageIndex; ///< The index of the turning page
400   int mIndex;            ///< The index to keep track which PanDisplacementProperty, CurrentCenterProperty is used for the current panning page
401   int mSlidingCount;     ///< The boolean vector to keep track whether there are animating pages sliding back
402   int mAnimatingCount;   ///< The boolean vector to keep track which PageTurnEffect, PanDisplacementProperty, CurrentCenterProperty is available for using
403
404   bool mConstraints; ///< The boolean to keep track the constrains are applied or not
405   bool mPress;       ///< The boolean to keep track the state of the pageTurnEffect is activated or not
406   bool mPageUpdated; ///< The boolean to keep track whether is page is updated after any turning activity
407
408   Toolkit::PageTurnView::PageTurnSignal mPageTurnStartedSignal;  ///< The signal to notify that a page has started turning
409   Toolkit::PageTurnView::PageTurnSignal mPageTurnFinishedSignal; ///< The signal to notify that a page has finished turning
410   Toolkit::PageTurnView::PagePanSignal  mPagePanStartedSignal;   ///< The signal to notify that a page has started panning
411   Toolkit::PageTurnView::PagePanSignal  mPagePanFinishedSignal;  ///< The signal to notify that a page has finished panning
412
413   static const char* const PROPERTY_TEXTURE_WIDTH;   ///< The uniform name of texture width
414   static const char* const PROPERTY_ORIGINAL_CENTER; ///< The property name of original center, which is used to constrain the uniforms
415   static const char* const PROPERTY_CURRENT_CENTER;  ///< The property name of current center, which is used to constrain the uniforms
416
417   static const int   MAXIMUM_TURNING_NUM;              ///< How many pages are allowed to animating in the same time
418   static const int   NUMBER_OF_CACHED_PAGES_EACH_SIDE; ///< The maximum number of pages kept, (MAXIMUM_ANIMATION_NUM+1) pages for each side
419   static const int   NUMBER_OF_CACHED_PAGES;           ///< The maximum number of pages kept, (MAXIMUM_ANIMATION_NUM+1)*2 pages in total
420   static const float STATIC_PAGE_INTERVAL_DISTANCE;    ///< The depth interval between stacked pages (static pages)
421 };
422
423 } // namespace Internal
424
425 // Helpers for public-api forwarding methods
426
427 inline Toolkit::Internal::PageTurnView& GetImplementation(Toolkit::PageTurnView& pub)
428 {
429   DALI_ASSERT_ALWAYS(pub);
430
431   Dali::RefObject& handle = pub.GetImplementation();
432
433   return static_cast<Toolkit::Internal::PageTurnView&>(handle);
434 }
435
436 inline const Toolkit::Internal::PageTurnView& GetImplementation(const Toolkit::PageTurnView& pub)
437 {
438   DALI_ASSERT_ALWAYS(pub);
439
440   const Dali::RefObject& handle = pub.GetImplementation();
441
442   return static_cast<const Toolkit::Internal::PageTurnView&>(handle);
443 }
444
445 } // namespace Toolkit
446
447 } // namespace Dali
448
449 #endif // DALI_TOOLKIT_INTERNAL_PAGE_TURN_VIEW_IMPL_H