Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / page-turn-view / page-turn-view-impl.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //     http://floralicense.org/license/
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an AS IS BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 // CLASS HEADER
18 #include <dali-toolkit/internal/controls/page-turn-view/page-turn-view-impl.h>
19
20 // INTERNAL INCLUDES
21 #include <dali-toolkit/public-api/controls/default-controls/solid-color-actor.h>
22
23 using namespace Dali;
24
25 namespace //unnamed namespace
26 {
27 // To register type
28 TypeRegistration mType( typeid(Toolkit::PageTurnView), typeid(Toolkit::Control), NULL );
29
30 // default grid density for page turn effect, 10 pixels by 10 pixels
31 const float DEFAULT_GRID_DENSITY(10.0f);
32
33 // to bent the page, the minimal horizontal pan start position is pageSize.x * MINIMUM_START_POSITION_RATIO
34 const float MINIMUM_START_POSITION_RATIO(0.6f);
35
36 // the maximum vertical displacement of pan gesture, if exceed, will reduce it: pageSize.y * MAXIMUM_VERTICAL_MOVEMENT_RATIO
37 const float MAXIMUM_VERTICAL_MOVEMENT_RATIO(0.15f);
38
39 // when the x component of pan position reaches pageSize.x * PAGE_TURN_OVER_THRESHOLD_RATIO, page starts to turn over
40 const float PAGE_TURN_OVER_THRESHOLD_RATIO(0.5f);
41
42 // duration of animation, shorter for faster speed
43 const float PAGE_SLIDE_BACK_ANIMATION_DURATION(1.0f);
44 const float PAGE_TURN_OVER_ANIMATION_DURATION(1.2f);
45
46 // the major&minor radius (in pixels) to form an ellipse shape
47 // the top-left quarter of this ellipse is used to calculate spine normal for simulating shadow
48 const Vector2 DEFAULT_SPINE_SHADOW_PARAMETER(50.0f, 20.0f);
49
50 // constants for shadow casting
51 const float POINT_LIGHT_HEIGHT_RATIO(2.f);
52 const Vector4 DEFAULT_SHADOW_COLOR = Vector4(0.2f, 0.2f, 0.2f, 0.5f);
53
54 // constraints ////////////////////////////////////////////////////////////////
55 /**
56  * Original Center Constraint
57  *
58  * This constraint adjusts the original center property of the page turn shader effect
59  * based on the X-direction displacement of the pan gesture
60  */
61 struct OriginalCenterConstraint
62 {
63   OriginalCenterConstraint(const Vector2& originalCenter, const Vector2& offset)
64   : mOldCenter( originalCenter )
65   {
66     mNewCenter = originalCenter + offset;
67     mDistance = offset.Length() * 0.5f;
68     mDirection = offset  / mDistance;
69   }
70
71   Vector2 operator()(const Vector2& current, const PropertyInput& panDisplacement)
72   {
73     float displacement = panDisplacement.GetFloat();
74
75     if( displacement < mDistance )
76     {
77       return mOldCenter + mDirection * displacement;
78     }
79     else
80     {
81       return mNewCenter + Vector2(0.25f*(displacement-mDistance), 0.f);
82     }
83   }
84
85   Vector2 mOldCenter;
86   Vector2 mNewCenter;
87   float mDistance;
88   Vector2 mDirection;
89 };
90
91 /**
92  * Rotation Constraint
93  *
94  * This constraint adjusts the rotation property of the page actor
95  * based on the X-direction displacement of the pan gesture
96  */
97 struct RotationConstraint
98 {
99   RotationConstraint( float distance, float pageWidth, bool isTurnBack )
100   : mDistance( distance*0.5f )
101   {
102     mStep = 1.f / pageWidth;
103     mSign = isTurnBack ? -1.0f : 1.0f;
104     mConst = isTurnBack ? -1.0f : 0.f;
105     mRotation = isTurnBack ? Quaternion( -Math::PI, Vector3::YAXIS ) : Quaternion( 0.f, Vector3::YAXIS );
106   }
107
108   Quaternion operator()( const Quaternion& current, const PropertyInput& panDisplacement )
109   {
110     float displacement = panDisplacement.GetFloat();
111     float angle;
112     if( displacement < mDistance)
113     {
114       return mRotation;
115     }
116     else
117     {
118       float coef = std::max(-1.0f, mStep*(mDistance-displacement));
119       angle = Math::PI*( mConst + mSign*coef );
120       return Quaternion( angle, Vector3::YAXIS );
121     }
122   }
123
124   float mDistance;
125   float mStep;
126   float mConst;
127   float mSign;
128   Quaternion mRotation;
129 };
130
131 /**
132  * Current Center Constraint
133  *
134  * This constraint adjusts the current center property of the page turn shader effect
135  * based on the pan position and the original center position
136  */
137 struct CurrentCenterConstraint
138 {
139   CurrentCenterConstraint( float pageWidth)
140   : mPageWidth( pageWidth )
141   {
142     mThres = pageWidth * PAGE_TURN_OVER_THRESHOLD_RATIO * 0.5f;
143   }
144
145   Vector2 operator()( const Vector2& current, const PropertyInput& center, const PropertyInput& originalCenter )
146   {
147     Vector2 centerPosition = center.GetVector2();
148     if( centerPosition.x > 0.f )
149     {
150       return Vector2( mThres+centerPosition.x*0.5f , centerPosition.y);
151     }
152     else
153     {
154       Vector2 centerOrigin = originalCenter.GetVector2();
155       Vector2 direction = centerOrigin - Vector2(mThres, centerPosition.y);
156       float coef = 1.f+(centerPosition.x*2.f / mPageWidth);
157       // Todo: when coef <= 0, the page is flat, slow down the last moment of the page stretch by 10 times to avoid a small bounce
158       if(coef < 0.025f)
159       {
160         coef = (coef+0.225f)/10.0f;
161       }
162       return centerOrigin - direction * coef;
163     }
164   }
165
166   float mPageWidth;
167   float mThres;
168 };
169
170 struct ShadowBlurStrengthConstraint
171 {
172   ShadowBlurStrengthConstraint( float thres )
173   : mThres( thres )
174   {}
175
176   float operator()( const float current,  const PropertyInput& currentCenter, const PropertyInput& originalCenter, const PropertyInput& panDisplacement)
177   {
178     float displacement = panDisplacement.GetFloat();
179     float blurStrength;
180     if( EqualsZero(displacement))
181     {
182       Vector2 cur = currentCenter.GetVector2();
183       Vector2 ori = originalCenter.GetVector2();
184       blurStrength =  5.f*(ori-cur).Length() / mThres;
185     }
186     else
187     {
188       blurStrength =  1.f - (displacement-2.f*mThres)/mThres;
189     }
190
191     blurStrength = blurStrength > 1.f ? 1.f : ( blurStrength < 0.f ? 0.f : blurStrength );
192     return blurStrength;
193   }
194
195   float mThres;
196 };
197
198 bool IsActorHittableFunction( Actor actor, Dali::HitTestAlgorithm::TraverseType type )
199 {
200   bool hittable = false;
201
202   switch (type)
203   {
204     case Dali::HitTestAlgorithm::CHECK_ACTOR:
205     {
206       // Check whether the actor is visible and not fully transparent.
207       Property::Index propertyActorHittable = actor.GetPropertyIndex(Toolkit::PageFactory::ACTOR_HITTABLE);
208       if( actor.IsSensitive()
209        && actor.IsVisible()
210        && actor.GetCurrentWorldColor().a > 0.01f// not FULLY_TRANSPARENT
211        && ( propertyActorHittable != Property::INVALID_INDEX &&
212             actor.GetProperty<bool>( propertyActorHittable ) ) )
213       {
214          hittable = true;
215       }
216       break;
217     }
218     case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
219     {
220       if( actor.IsSensitive() && actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
221       {
222         hittable = true;
223       }
224       break;
225     }
226     default:
227     {
228       break;
229     }
230   }
231
232   return hittable;
233 }
234
235 } //unnamed namespace
236
237 namespace Dali
238 {
239
240 namespace Toolkit
241 {
242
243 namespace Internal
244 {
245
246 // these several constants are also used in the derived classes
247 const int PageTurnView::MAXIMUM_TURNING_NUM = 4;
248 const int PageTurnView::NUMBER_OF_CACHED_PAGES_EACH_SIDE = MAXIMUM_TURNING_NUM + 1;
249 const int PageTurnView::NUMBER_OF_CACHED_PAGES = NUMBER_OF_CACHED_PAGES_EACH_SIDE*2;
250 const float PageTurnView::STATIC_PAGE_INTERVAL_DISTANCE = 1.0f;
251
252 PageTurnView::PageTurnView( PageFactory& pageFactory, const Vector2& pageSize )
253 : ControlImpl( true ),
254   mPageFactory( pageFactory ),
255   mPageSize( pageSize ),
256   mIsEditMode( false ),
257   mPanning( false ),
258   mSpineShadowParameter( DEFAULT_SPINE_SHADOW_PARAMETER ),
259   mCurrentPageIndex( 0 ),
260   mIndex( 0 ),
261   mPress( false ),
262   mPageUpdated( true ),
263   mPageTurnStartedSignal(),
264   mPageTurnFinishedSignal(),
265   mPagePanStartedSignal(),
266   mPagePanFinishedSignal()
267 {
268   mPageActors.resize( NUMBER_OF_CACHED_PAGES );
269   mIsAnimating.resize( MAXIMUM_TURNING_NUM );
270   mIsSliding.resize( MAXIMUM_TURNING_NUM );
271   mTurnEffect.resize( MAXIMUM_TURNING_NUM );
272   mPropertyPanDisplacement.resize( MAXIMUM_TURNING_NUM );
273   mPropertyCurrentCenter.resize( MAXIMUM_TURNING_NUM );
274 }
275
276 PageTurnView::~PageTurnView()
277 {
278 }
279
280 void PageTurnView::OnInitialize()
281 {
282    // create the two book spine effect for static images, left and right side pages respectively
283   mSpineEffectFront = PageTurnBookSpineEffect::New();
284   mSpineEffectFront.SetIsBackImageVisible( false );
285   mSpineEffectFront.SetPageWidth( mPageSize.width );
286   mSpineEffectFront.SetShadowWidth( 0.f );
287   mSpineEffectFront.SetSpineShadowParameter( mSpineShadowParameter );
288
289   mSpineEffectBack = PageTurnBookSpineEffect::New();
290   mSpineEffectBack.SetIsBackImageVisible( true );
291   mSpineEffectBack.SetPageWidth( mPageSize.width );
292   mSpineEffectBack.SetShadowWidth( 0.f );
293   mSpineEffectBack.SetSpineShadowParameter( mSpineShadowParameter );
294
295   // create the page turn effect objects
296   for( int i = 0; i < MAXIMUM_TURNING_NUM; i++ )
297   {
298     mTurnEffect[i] = Toolkit::PageTurnEffect::New( false );
299     mTurnEffect[i].SetProperty( ShaderEffect::GRID_DENSITY, Property::Value( DEFAULT_GRID_DENSITY ) );
300     mTurnEffect[i].SetPageSize( mPageSize );
301     mTurnEffect[i].SetShadowWidth(0.f);
302     mTurnEffect[i].SetSpineShadowParameter( mSpineShadowParameter );
303     mIsAnimating[i] = false;
304     mIsSliding[i] = false;
305     mPropertyPanDisplacement[i] = Self().RegisterProperty("PAN_DISPLACEMENT_PROPERTY_"+i, 0.0f);
306     mPropertyCurrentCenter[i] = Self().RegisterProperty("CURRENT_CENTER_PROPERTY_"+i, Vector2(0.0f,0.0f));
307   }
308
309   mTurningPageLayer = Layer::New();
310   mTurningPageLayer.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
311   // Set control size and the parent origin of turningPageLayer
312   OnPageTurnViewInitialize();
313
314   mRootOnScreen = Actor::New();
315   mRootOnScreen.SetPositionInheritanceMode( USE_PARENT_POSITION );
316   mRootOnScreen.SetSize( mControlSize );
317   Self().Add( mRootOnScreen );
318   mRootOnScreen.Add(mTurningPageLayer);
319
320   mTotalPageCount = static_cast<int>( mPageFactory.GetNumberOfPages() );
321   mNeedOffscreenRendering = mPageFactory.IsOffscreenRenderingNeeded();
322   if( mNeedOffscreenRendering )
323   {
324     SetupRenderTasks();
325   }
326
327   // add pages to the scene, and set depth for the stacked pages
328   for( int i = 0; i < NUMBER_OF_CACHED_PAGES_EACH_SIDE; i++ )
329   {
330     AddPage( i );
331     if(mPageActors[i])
332     {
333       mPageActors[i].SetZ( -static_cast<float>( i )*STATIC_PAGE_INTERVAL_DISTANCE );
334     }
335   }
336
337   // enable the pan gesture which is attached to the control
338   EnableGestureDetection(Gesture::Type(Gesture::Pan));
339
340   mPageFactory.PageRefreshSignal().Connect(this, &PageTurnView::RenderPage);
341 }
342
343 void PageTurnView::SetupRenderTasks()
344 {
345   mPageSourceActor.resize( NUMBER_OF_CACHED_PAGES );
346   mOffscreenTask.resize( NUMBER_OF_CACHED_PAGES );
347   mRenderedPage.resize( NUMBER_OF_CACHED_PAGES );
348
349   mCameraActor = CameraActor::New(mControlSize);
350   mCameraActor.SetParentOrigin(ParentOrigin::CENTER);
351   mCameraActor.SetPositionInheritanceMode( DONT_INHERIT_POSITION );
352   mCameraActor.SetInheritScale( false );
353   Self().Add(mCameraActor);
354
355   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
356   for(int i=0; i<NUMBER_OF_CACHED_PAGES; i++)
357   {
358     mPageSourceActor[i] = Actor::New();
359     mPageSourceActor[i].SetParentOrigin(ParentOrigin::CENTER);
360     mPageSourceActor[i].SetColorMode( USE_OWN_COLOR );
361     mPageSourceActor[i].SetPositionInheritanceMode( DONT_INHERIT_POSITION );
362     mPageSourceActor[i].SetInheritScale( false );
363     Self().Add( mPageSourceActor[i] );
364     mPageSourceActor[i].SetSensitive( false );
365
366     mRenderedPage[i] = FrameBufferImage::New( mControlSize.width, mControlSize.height, Pixel::RGB8888, Image::Unused );
367     mOffscreenTask[i] = taskList.CreateTask();
368     mOffscreenTask[i].SetRefreshRate( RenderTask::REFRESH_ONCE );
369     mOffscreenTask[i].SetCameraActor(mCameraActor);
370     mOffscreenTask[i].SetSourceActor( mPageSourceActor[i] );
371     mOffscreenTask[i].SetExclusive(true);
372     mOffscreenTask[i].SetInputEnabled( false );
373     mOffscreenTask[i].SetClearEnabled( true );
374     mOffscreenTask[i].SetClearColor( Vector4(0.f,0.f,0.f,0.f) );
375     mOffscreenTask[i].SetTargetFrameBuffer( mRenderedPage[i] );
376     mOffscreenTask[i].SetScreenToFrameBufferMappingActor( Self() );
377    }
378 }
379
380 void PageTurnView::SetupShadowView()
381 {
382   mShadowView = Toolkit::ShadowView::New( 0.25f, 0.25f );
383   Vector3 origin = mTurningPageLayer.GetCurrentParentOrigin();
384   mShadowView.SetParentOrigin( origin );
385   mShadowView.SetAnchorPoint( origin );
386   mShadowView.SetPointLightFieldOfView( Math::PI / 2.0f);
387   mShadowView.SetShadowColor(DEFAULT_SHADOW_COLOR);
388
389   mShadowLayer = Layer::New();
390   mShadowLayer.SetPositionInheritanceMode( USE_PARENT_POSITION );
391   mRootOnScreen.Add(mShadowLayer);
392   mShadowLayer.Raise();
393
394   mShadowPlane = CreateSolidColorActor( Vector4 (0.0f, 0.0f, 0.0f, 0.0f) );
395   mShadowPlane.SetPositionInheritanceMode( USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
396   mShadowPlane.SetSize( mControlSize );
397   mShadowLayer.Add( mShadowPlane );
398   mShadowView.SetShadowPlane( mShadowPlane );
399
400   mPointLight = Actor::New();
401   mPointLight.SetAnchorPoint( origin );
402   mPointLight.SetParentOrigin( origin );
403   mPointLight.SetPosition( 0.f, 0.f, mPageSize.width*POINT_LIGHT_HEIGHT_RATIO );
404   mRootOnScreen.Add( mPointLight );
405   mShadowView.SetPointLight( mPointLight );
406
407   mTurningPageLayer.Add( mShadowView );
408   mShadowView.Activate();
409 }
410
411 void PageTurnView::OnControlStageConnection()
412 {
413   SetupShadowView();
414   mTurningPageLayer.RaiseToTop();
415 }
416
417 void PageTurnView::OnControlStageDisconnection()
418 {
419   if(mShadowView)
420   {
421     Self().Remove(mPointLight);
422     Self().Remove(mShadowLayer);
423     mTurningPageLayer.Remove( mShadowView );
424   }
425
426   // make sure the status of the control is updated correctly when the pan gesture is interrupted
427   if(mPanning)
428   {
429     mPanning = false;
430
431     mRootOnScreen.Add(mPanActor);
432     mIsAnimating[mIndex] = false;
433     mPanActor.RemoveConstraints();
434     mTurnEffect[mIndex].RemoveConstraints();
435     mPageUpdated = true;
436
437     SetSpineEffect( mPanActor, mIsTurnBack[mPanActor] );
438   }
439 }
440
441 void PageTurnView::OnControlSizeSet( const Vector3& size )
442 {
443   // disable the SetSize of the control from the application
444   Self().SetSize( mControlSize );
445 }
446
447 void PageTurnView::SetSpineShadowParameter( const Vector2& spineShadowParameter )
448 {
449   mSpineShadowParameter = spineShadowParameter;
450
451   // set spine shadow parameter to all the shader effects
452   mSpineEffectFront.SetSpineShadowParameter( mSpineShadowParameter );
453   mSpineEffectBack.SetSpineShadowParameter( mSpineShadowParameter );
454   for( int i = 0; i < MAXIMUM_TURNING_NUM; i++ )
455   {
456     mTurnEffect[i].SetSpineShadowParameter( mSpineShadowParameter );
457   }
458 }
459
460 Vector2 PageTurnView::GetSpineShadowParameter()
461 {
462   return mSpineShadowParameter;
463 }
464
465 void PageTurnView::GoToPage( unsigned int pageId )
466 {
467   int pageIdx = static_cast<int>(pageId);
468   // record the new current page index
469   mCurrentPageIndex = pageIdx;
470
471   // clear the old pages
472   for(int i = 0; i < NUMBER_OF_CACHED_PAGES; i++ )
473   {
474     if( mPageActors[i] )
475     {
476       mPageActors[i].Unparent();
477       mPageActors[i].Reset();
478     }
479   }
480
481   // add the current page and the pages right before and after it
482   for( int i = pageIdx - NUMBER_OF_CACHED_PAGES_EACH_SIDE; i < pageIdx + NUMBER_OF_CACHED_PAGES_EACH_SIDE; i++ )
483   {
484     AddPage( i );
485   }
486   // set ordered depth to the stacked pages
487   OrganizePageDepth();
488 }
489
490 unsigned int PageTurnView::GetCurrentPage()
491 {
492   DALI_ASSERT_ALWAYS( mCurrentPageIndex >= 0 );
493   return static_cast< unsigned int >( mCurrentPageIndex );
494 }
495
496 Actor PageTurnView::EnterEditMode()
497 {
498   if( mNeedOffscreenRendering )
499   {
500     DALI_ASSERT_ALWAYS( mCurrentPageIndex >= 0 );
501
502     mIsEditMode = true;
503
504     int index = mCurrentPageIndex % NUMBER_OF_CACHED_PAGES;
505     mOffscreenTask[index].SetInputEnabled( true );
506     mPageSourceActor[index].SetSensitive( true );
507     mOffscreenTask[index].SetRefreshRate( RenderTask::REFRESH_ALWAYS );
508
509     mRootOnScreen.SetSensitive(false);
510
511     return mPageSourceActor[index].GetChildAt( 0 );
512   }
513   else
514   {
515     return Actor();
516   }
517 }
518
519 void PageTurnView::LeaveEditMode()
520 {
521   if( mNeedOffscreenRendering )
522   {
523     DALI_ASSERT_ALWAYS( mCurrentPageIndex >= 0 );
524
525     mIsEditMode = false;
526
527     int index = mCurrentPageIndex % NUMBER_OF_CACHED_PAGES;
528     mOffscreenTask[index].SetInputEnabled( false );
529     mPageSourceActor[index].SetSensitive( false );
530     mOffscreenTask[index].SetRefreshRate( RenderTask::REFRESH_ONCE );
531
532     mRootOnScreen.SetSensitive(true);
533   }
534 }
535
536 Actor PageTurnView::GetHitActor( Vector2& screenCoordinates, Vector2& actorCoordinates )
537 {
538   if( mNeedOffscreenRendering && mCurrentPageIndex < mTotalPageCount)
539   {
540     int index = mCurrentPageIndex % NUMBER_OF_CACHED_PAGES;
541
542     Dali::HitTestAlgorithm::Results results;
543     if( !mOffscreenTask[index].GetInputEnabled() )
544     {
545       mOffscreenTask[index].SetInputEnabled( true );
546       mPageSourceActor[index].SetSensitive( true );
547       Dali::HitTestAlgorithm::HitTest( mOffscreenTask[index], screenCoordinates, results, IsActorHittableFunction );
548       mOffscreenTask[index].SetInputEnabled( false );
549       mPageSourceActor[index].SetSensitive( false );
550     }
551     else
552     {
553       Dali::HitTestAlgorithm::HitTest( mOffscreenTask[index], screenCoordinates, results, IsActorHittableFunction );
554     }
555     actorCoordinates = results.actorCoordinates;
556     return results.actor;
557   }
558   else
559   {
560     return Actor();
561   }
562 }
563
564 void PageTurnView::AddPage( int pageIndex )
565 {
566   if(pageIndex > -1  && pageIndex < mTotalPageCount) // whether the page is available from the page factory
567   {
568     int index = pageIndex % NUMBER_OF_CACHED_PAGES;
569     ImageActor newPage;
570     if( mNeedOffscreenRendering )
571     {
572       Actor source = mPageFactory.NewPage( pageIndex );
573       if( mPageSourceActor[index].GetChildCount() > 0 )
574       {
575         mPageSourceActor[index].Remove( mPageSourceActor[index].GetChildAt( 0 ) );
576       }
577       mPageSourceActor[index].Add( source );
578       mOffscreenTask[index].SetRefreshRate( RenderTask::REFRESH_ONCE );
579       newPage = NewPageFromRenderBuffer( pageIndex );
580     }
581     else
582     {
583       newPage= ImageActor::DownCast( mPageFactory.NewPage( pageIndex ) );
584       DALI_ASSERT_ALWAYS( newPage );
585     }
586     newPage.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
587     newPage.SetParentOrigin( ParentOrigin::CENTER_LEFT );
588     newPage.SetSize( mPageSize );
589     mRootOnScreen.Add( newPage );
590     mPageActors[index] = newPage;
591
592     bool isLeftSide = ( pageIndex < mCurrentPageIndex );
593     mIsTurnBack[ newPage ] = isLeftSide;
594     if( isLeftSide )
595     {
596       // new page is added to the left side, so need to rotate it 180 degrees
597       newPage.RotateBy( Degree(-180.0f ), Vector3::YAXIS );
598     }
599     else
600     {
601       SetShaderEffect( newPage, mSpineEffectFront);
602     }
603
604     // For Portrait, nothing to do
605     // For Landscape, set spineEffectBack to the new effect if it is in the left side, and set properties to the back image actor if it exists
606     OnAddPage( newPage, isLeftSide );
607   }
608 }
609
610 void PageTurnView::RemovePage( int pageIndex )
611 {
612   if( pageIndex > -1 && pageIndex < mTotalPageCount)
613   {
614     int index = pageIndex % NUMBER_OF_CACHED_PAGES;
615     mPageActors[index].Unparent();
616     mIsTurnBack.erase( mPageActors[index] );
617     mPageActors[index].Reset();
618     if( mNeedOffscreenRendering )
619     {
620       mPageSourceActor[index].Remove( mPageSourceActor[index].GetChildAt( 0 ) );
621     }
622   }
623 }
624
625 void PageTurnView::RenderPage( int pageIndex )
626 {
627   if( pageIndex > std::max(-1, mCurrentPageIndex - NUMBER_OF_CACHED_PAGES_EACH_SIDE -1)
628    && pageIndex < std::min(mTotalPageCount, mCurrentPageIndex + NUMBER_OF_CACHED_PAGES_EACH_SIDE))
629   {
630     int index = pageIndex % NUMBER_OF_CACHED_PAGES;
631     mOffscreenTask[index].SetRefreshRate( RenderTask::REFRESH_ONCE );
632   }
633 }
634
635 void PageTurnView::RefreshAll()
636 {
637   mTotalPageCount = static_cast<int>( mPageFactory.GetNumberOfPages() );
638   if( mTotalPageCount > 0 )
639   {
640     if(mCurrentPageIndex < mTotalPageCount)
641     {
642       GoToPage( mCurrentPageIndex );
643     }
644     else
645     {
646       GoToPage( mCurrentPageIndex-- );
647     }
648   }
649 }
650
651 void PageTurnView::RefreshCurrentPage()
652 {
653   RenderPage( mCurrentPageIndex );
654 }
655
656 void PageTurnView::OnPan( PanGesture gesture )
657 {
658   if( mIsEditMode )
659   {
660     // when interrupted by the call of DisplayCurrentPageSourceActor(),
661     // make sure the panFinished is always called before stopping to responding the gesture
662     // so the status of the control is updated correctly
663     if(mPanning)
664     {
665       mPanning = false;
666       PanFinished( SetPanPosition( gesture.position ), gesture.GetSpeed() );
667     }
668
669     return;
670   }
671   // the pan gesture is attached to control itself instead of each page
672   switch( gesture.state )
673   {
674     case Gesture::Started:
675     {
676       mPanning = true;
677       // to find out whether the undergoing turning page number already reaches the maximum allowed
678       // and get one idle index when it is animatable
679       bool animatable = false;
680       for( int i = 0; i < MAXIMUM_TURNING_NUM; i++ )
681       {
682         if( !mIsAnimating[mIndex] )
683         {
684           animatable = true;
685           break;
686         }
687         if( mIsSliding[mIndex] )
688         {
689           animatable = false;
690           break;
691         }
692         mIndex++;
693         mIndex = mIndex % MAXIMUM_TURNING_NUM;
694       }
695
696       if( mPageUpdated && animatable )
697       {
698         SetPanActor( gesture.position ); // determine which page actor is panned
699         if(mPanActor && mPanActor.GetParent() != mRootOnScreen) // if the page is added to turning layer,it is undergoing an animation currently
700         {
701           mPanActor.Reset();
702         }
703         PanStarted( SetPanPosition( gesture.position ) );  // pass in the pan position in the local page coordinate
704       }
705       else
706       {
707         mPanActor.Reset();
708       }
709       break;
710     }
711     case Gesture::Continuing:
712     {
713       PanContinuing( SetPanPosition( gesture.position ) ); // pass in the pan position in the local page coordinate
714       break;
715     }
716     case Gesture::Finished:
717     case Gesture::Cancelled:
718     {
719       mPanning = false;
720       PanFinished( SetPanPosition( gesture.position ), gesture.GetSpeed() );
721       break;
722     }
723     case Gesture::Clear:
724     case Gesture::Possible:
725     default:
726     {
727       break;
728     }
729   }
730 }
731
732 void PageTurnView::PanStarted( const Vector2& gesturePosition )
733 {
734   mPressDownPosition = gesturePosition;
735
736   if( !mPanActor )
737   {
738     return;
739   }
740
741   mOriginalCenter = gesturePosition;
742   mTurnEffect[mIndex].SetIsTurningBack( mIsTurnBack[ mPanActor] );
743   mPress = false;
744   mPageUpdated = false;
745
746   // Guard against destruction during signal emission
747   Toolkit::PageTurnView handle( GetOwner() );
748   mPagePanStartedSignal.Emit( handle );
749 }
750
751 void PageTurnView::PanContinuing( const Vector2& gesturePosition )
752 {
753   if( !mPanActor )
754   {
755     return;
756   }
757
758   // Guard against destruction during signal emission
759   Toolkit::PageTurnView handle( GetOwner() );
760
761   if(!mPress)
762   {
763     // when the touch down position is near the spine
764     // or when the panning goes outwards or some other position which would tear the paper in real situation
765     // we change the start position into the current panning position and update the shader parameters
766     if( mOriginalCenter.x <  mPageSize.width*MINIMUM_START_POSITION_RATIO
767         || gesturePosition.x > mOriginalCenter.x-1.0f
768         || ( ( gesturePosition.x/mOriginalCenter.x > gesturePosition.y/mOriginalCenter.y ) &&
769              ( gesturePosition.x/mOriginalCenter.x > (gesturePosition.y-mPageSize.height )/(mOriginalCenter.y-mPageSize.height ) ) ) )
770     {
771       mOriginalCenter = gesturePosition;
772     }
773     else
774     {
775       mDistanceUpCorner = mOriginalCenter.Length();
776       mDistanceBottomCorner = ( mOriginalCenter - Vector2( 0.0f, mPageSize.height ) ).Length();
777       mShadowView.Add( mPanActor );
778       SetShaderEffect( mPanActor, mTurnEffect[mIndex] );
779       mTurnEffect[mIndex].SetOriginalCenter( mOriginalCenter );
780       mCurrentCenter = mOriginalCenter;
781       mTurnEffect[mIndex].SetCurrentCenter( mCurrentCenter );
782       mPanDisplacement = 0.f;
783       mConstraints = true;
784       mPress = true;
785       mIsAnimating[mIndex] = true;
786
787       mPageTurnStartedSignal.Emit( handle, static_cast<unsigned int>(mCurrentPageIndex + ( ( mIsTurnBack[mPanActor] ) ? -1 : 0 ) ), !mIsTurnBack[mPanActor] );
788
789       mShadowView.RemoveConstraints();
790       Actor self = Self();
791       self.SetProperty( mPropertyPanDisplacement[mIndex], 0.f );
792       Constraint shadowBlurStrengthConstraint = Constraint::New<float>( mShadowView.GetBlurStrengthPropertyIndex(),
793                                                                         Source(mTurnEffect[mIndex],  mTurnEffect[mIndex].GetPropertyIndex(mTurnEffect[mIndex].PageTurnEffect::GetCurrentCenterPropertyName())),
794                                                                         Source(mTurnEffect[mIndex],  mTurnEffect[mIndex].GetPropertyIndex(mTurnEffect[mIndex].PageTurnEffect::GetOriginalCenterPropertyName())),
795                                                                         Source( self, mPropertyPanDisplacement[mIndex] ),
796                                                                         ShadowBlurStrengthConstraint( mPageSize.width*PAGE_TURN_OVER_THRESHOLD_RATIO ) );
797       mShadowView.ApplyConstraint( shadowBlurStrengthConstraint  );
798     }
799   }
800   else
801   {
802     Vector2 currentCenter = gesturePosition;
803
804     // Test whether the new current center would tear the paper from the top pine in real situation
805     // we do not forbid this totally, which would restrict the panning gesture too much
806     // instead, set it to the nearest allowable position
807     float distanceUpCorner = currentCenter.Length();
808     float distanceBottomCorner = ( currentCenter-Vector2( 0.0f, mPageSize.height ) ).Length();
809     if( distanceUpCorner > mDistanceUpCorner )
810     {
811       currentCenter = currentCenter*mDistanceUpCorner/distanceUpCorner;
812     }
813     // would tear the paper from the bottom spine in real situation
814     if( distanceBottomCorner > mDistanceBottomCorner )
815     {
816       currentCenter = ( ( currentCenter - Vector2( 0.0f, mPageSize.height ) )*mDistanceBottomCorner/distanceBottomCorner + Vector2(0.0f,mPageSize.height ) );
817     }
818     // If direction has a very high y component, reduce it.
819     Vector2 curveDirection = currentCenter - mOriginalCenter;
820     if( fabs( curveDirection.y ) > fabs( curveDirection.x ) )
821     {
822       currentCenter.y = mOriginalCenter.y + ( currentCenter.y - mOriginalCenter.y ) * fabs( curveDirection.x/curveDirection.y );
823     }
824     // If the vertical distance is high, reduce it
825     float yShift = currentCenter.y - mOriginalCenter.y;
826     if( fabs( yShift ) > mPageSize.height * MAXIMUM_VERTICAL_MOVEMENT_RATIO )
827     {
828       currentCenter.y = mOriginalCenter.y + yShift*mPageSize.height*MAXIMUM_VERTICAL_MOVEMENT_RATIO/fabs(yShift );
829     }
830
831     // use contraints to control the page shape and rotation when the pan position is near the spine
832     if( currentCenter.x <= mPageSize.width*PAGE_TURN_OVER_THRESHOLD_RATIO && mOriginalCenter.x > mPageSize.width*PAGE_TURN_OVER_THRESHOLD_RATIO )
833     {
834       // set the property values used by the constraints
835       mPanDisplacement = mPageSize.width*PAGE_TURN_OVER_THRESHOLD_RATIO - currentCenter.x;
836       Self().SetProperty( mPropertyPanDisplacement[mIndex], mPanDisplacement );
837       Self().SetProperty( mPropertyCurrentCenter[mIndex], currentCenter );
838
839       // set up the OriginalCenterConstraint and CurrentCebterConstraint to the PageTurnEdffect
840       // also set up the RotationConstraint to the page actor
841       if( mConstraints )
842       {
843         Vector2 corner;
844         // the corner position need to be a little far away from the page edge to ensure the whole page is lift up
845         if( currentCenter.y >= mOriginalCenter.y )
846         {
847           corner = Vector2( 1.1f*mPageSize.width, 0.f );
848         }
849         else
850         {
851           corner = mPageSize*1.1f;
852         }
853
854         Vector2 offset( currentCenter-mOriginalCenter );
855         float k = - ( (mOriginalCenter.x-corner.x)*offset.x + (mOriginalCenter.y-corner.y)*offset.y )
856                    /( offset.x*offset.x + offset.y*offset.y );
857         offset *= k;
858         Actor self = Self();
859         Source source(self, mPropertyPanDisplacement[mIndex]);
860
861         Property::Index shaderOriginalCenterPropertyIndex = mTurnEffect[mIndex].GetPropertyIndex(mTurnEffect[mIndex].PageTurnEffect::GetOriginalCenterPropertyName());
862         Constraint originalCenterConstraint = Constraint::New<Vector2>( shaderOriginalCenterPropertyIndex ,
863                                                                         source,
864                                                                         OriginalCenterConstraint( mOriginalCenter, offset ));
865         mTurnEffect[mIndex].ApplyConstraint( originalCenterConstraint );
866
867         Property::Index shaderCurrentCenterPropertyIndex = mTurnEffect[mIndex].GetPropertyIndex(mTurnEffect[mIndex].PageTurnEffect::GetCurrentCenterPropertyName());
868         Constraint currentCenterConstraint = Constraint::New<Vector2>( shaderCurrentCenterPropertyIndex,
869                                                                        Source(self, mPropertyCurrentCenter[mIndex]),
870                                                                        Source(mTurnEffect[mIndex], shaderOriginalCenterPropertyIndex),
871                                                                        CurrentCenterConstraint(mPageSize.width));
872         mTurnEffect[mIndex].ApplyConstraint( currentCenterConstraint );
873
874         GetImpl( mTurnEffect[mIndex] ).ApplyInternalConstraint();
875
876         float distance = offset.Length();
877         Constraint rotationConstraint = Constraint::New<Quaternion>( Actor::ROTATION,
878                                                                      Source( self, mPropertyPanDisplacement[mIndex] ),
879                                                                      RotationConstraint(distance, mPageSize.width, mIsTurnBack[mPanActor]));
880         mPanActor.ApplyConstraint( rotationConstraint );
881
882         mConstraints = false;
883       }
884     }
885     else
886     {
887       if(!mConstraints) // remove the constraint is the pan position move back to far away from the spine
888       {
889         mPanActor.RemoveConstraints();
890         mTurnEffect[mIndex].RemoveConstraints();
891         mTurnEffect[mIndex].SetOriginalCenter( mOriginalCenter );
892         mConstraints = true;
893         mPanDisplacement = 0.f;
894       }
895
896       mTurnEffect[mIndex].SetCurrentCenter( currentCenter );
897       mCurrentCenter = currentCenter;
898       GetImpl( mTurnEffect[mIndex] ).ApplyInternalConstraint();
899     }
900   }
901 }
902
903 void PageTurnView::PanFinished( const Vector2& gesturePosition, float gestureSpeed )
904 {
905   // Guard against destruction during signal emission
906   Toolkit::PageTurnView handle( GetOwner() );
907
908   if( !mPanActor )
909   {
910     if(!mIsAnimating[mIndex])
911     {
912       OnPossibleOutwardsFlick( gesturePosition, gestureSpeed );
913     }
914     return;
915   }
916
917   mPagePanFinishedSignal.Emit( handle );
918
919   Actor actor = mPanActor;
920   if(mPress)
921   {
922     if(!mConstraints) // if with constraints, the pan finished position is near spine, set up an animation to turn the page over
923     {
924       // update the pages here instead of in the TurnedOver callback function
925       // as new page is allowed to respond to the pan gesture before other pages finishing animation
926       if(mIsTurnBack[actor])
927       {
928         mCurrentPageIndex--;
929         RemovePage( mCurrentPageIndex+NUMBER_OF_CACHED_PAGES_EACH_SIDE );
930         AddPage( mCurrentPageIndex-NUMBER_OF_CACHED_PAGES_EACH_SIDE );
931       }
932       else
933       {
934         mCurrentPageIndex++;
935         RemovePage( mCurrentPageIndex-NUMBER_OF_CACHED_PAGES_EACH_SIDE-1 );
936         AddPage( mCurrentPageIndex+NUMBER_OF_CACHED_PAGES_EACH_SIDE-1 );
937       }
938       OrganizePageDepth();
939
940       // set up an animation to turn the page over
941       Actor self = Self();
942       float width = mPageSize.width*(1.f+PAGE_TURN_OVER_THRESHOLD_RATIO);
943       Animation animation = Animation::New( std::max(0.1f,PAGE_TURN_OVER_ANIMATION_DURATION * (1.0f - mPanDisplacement / width)) );
944       animation.AnimateTo( Property(self, mPropertyPanDisplacement[mIndex]),
945                            width,AlphaFunctions::EaseOutSine33);
946       animation.AnimateTo( Property(self, mPropertyCurrentCenter[mIndex]),
947                            Vector2(-mPageSize.width, 0.5f*mPageSize.height), AlphaFunctions::EaseOutSine33);
948       mAnimationActorPair[animation] = actor;
949       mAnimationIndexPair[animation] = mIndex;
950       animation.Play();
951       animation.FinishedSignal().Connect( this, &PageTurnView::TurnedOver );
952     }
953     else // the pan finished position is far away from the spine, set up an animation to slide the page back instead of turning over
954     {
955       Animation animation= Animation::New( PAGE_SLIDE_BACK_ANIMATION_DURATION * (mOriginalCenter.x - mCurrentCenter.x) / mPageSize.width / PAGE_TURN_OVER_THRESHOLD_RATIO );
956       animation.AnimateTo( Property( mTurnEffect[mIndex], mTurnEffect[mIndex].PageTurnEffect::GetCurrentCenterPropertyName() ),
957                            mOriginalCenter, AlphaFunctions::Linear );
958       mAnimationActorPair[animation] = actor;
959       mAnimationIndexPair[animation] = mIndex;
960       animation.Play();
961       mIsSliding[mIndex] = true;
962       animation.FinishedSignal().Connect( this, &PageTurnView::SliddenBack );
963
964       mPageTurnStartedSignal.Emit( handle, static_cast<unsigned int>( mCurrentPageIndex + ( ( mIsTurnBack[mPanActor] ) ? -1 : 0 ) ), mIsTurnBack[mPanActor] );
965     }
966   }
967   else
968   {
969     // In portrait view, an outwards flick should turn the previous page back
970     // In landscape view, nothing to do
971     OnPossibleOutwardsFlick( gesturePosition, gestureSpeed );
972   }
973
974   mPageUpdated = true;
975 }
976
977 void PageTurnView::TurnedOver( Animation& animation )
978 {
979   Actor actor = mAnimationActorPair[animation];
980   mIsTurnBack[actor] = !mIsTurnBack[actor];
981   actor.RemoveConstraints();
982   mRootOnScreen.Add(actor);
983   int index = mAnimationIndexPair[animation];
984   mIsAnimating[index] = false;
985   mTurnEffect[index].RemoveConstraints();
986   mAnimationIndexPair.erase( animation );
987   mAnimationActorPair.erase( animation );
988
989   SetSpineEffect( actor, mIsTurnBack[actor] );
990
991   // Guard against destruction during signal emission
992   Toolkit::PageTurnView handle( GetOwner() );
993   mPageTurnFinishedSignal.Emit( handle, static_cast<unsigned int>( mCurrentPageIndex + ( ( mIsTurnBack[actor] ) ? -1 : 0 ) ), mIsTurnBack[actor] );
994 }
995
996 void PageTurnView::SliddenBack( Animation& animation )
997 {
998   Actor actor = mAnimationActorPair[animation];
999   mRootOnScreen.Add(actor);
1000   int index = mAnimationIndexPair[animation];
1001   mIsSliding[index] = false;
1002   mIsAnimating[index] = false;
1003   mAnimationIndexPair.erase( animation );
1004   mAnimationActorPair.erase( animation );
1005
1006   SetSpineEffect( actor, mIsTurnBack[actor] );
1007
1008   // Guard against destruction during signal emission
1009   Toolkit::PageTurnView handle( GetOwner() );
1010   mPageTurnFinishedSignal.Emit( handle, static_cast<unsigned int>( mCurrentPageIndex + ( ( mIsTurnBack[mPanActor] ) ? -1 : 0 ) ), mIsTurnBack[actor] );
1011 }
1012
1013 void PageTurnView::OrganizePageDepth()
1014 {
1015   for( int i=0; i<NUMBER_OF_CACHED_PAGES_EACH_SIDE;i++ )
1016   {
1017     if(mCurrentPageIndex+i < mTotalPageCount)
1018     {
1019       mPageActors[( mCurrentPageIndex+i )%NUMBER_OF_CACHED_PAGES].SetZ( -static_cast<float>( i )*STATIC_PAGE_INTERVAL_DISTANCE );
1020     }
1021     if( mCurrentPageIndex >= i + 1 )
1022     {
1023       mPageActors[( mCurrentPageIndex-i-1 )%NUMBER_OF_CACHED_PAGES].SetZ( -static_cast<float>( i )*STATIC_PAGE_INTERVAL_DISTANCE );
1024     }
1025   }
1026 }
1027
1028 void PageTurnView::SetShaderEffect( Actor actor, ShaderEffect shaderEffect )
1029 {
1030   actor.SetShaderEffect( shaderEffect );
1031
1032   if( actor.GetChildCount() > 0 )
1033   {
1034     actor.GetChildAt( 0 ).SetShaderEffect(shaderEffect);
1035   }
1036 }
1037
1038 Toolkit::PageTurnView::PageTurnSignal& PageTurnView::PageTurnStartedSignal()
1039 {
1040   return mPageTurnStartedSignal;
1041 }
1042
1043 Toolkit::PageTurnView::PageTurnSignal& PageTurnView::PageTurnFinishedSignal()
1044 {
1045   return mPageTurnFinishedSignal;
1046 }
1047
1048 Toolkit::PageTurnView::PagePanSignal& PageTurnView::PagePanStartedSignal()
1049 {
1050   return mPagePanStartedSignal;
1051 }
1052
1053 Toolkit::PageTurnView::PagePanSignal& PageTurnView::PagePanFinishedSignal()
1054 {
1055   return mPagePanFinishedSignal;
1056 }
1057
1058 } // namespace Internal
1059
1060 } // namespace Toolkit
1061
1062 } // namespace Dali