Split dali-toolkit into Base & Optional
[platform/core/uifw/dali-toolkit.git] / base / dali-toolkit / internal / controls / scrollable / scroll-view / scroll-view-twist-effect-impl.cpp
1
2 //
3 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
4 //
5 // Licensed under the Flora License, Version 1.0 (the License);
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 //     http://floralicense.org/license/
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an AS IS BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17
18 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-effect-impl.h>
19 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-twist-effect-impl.h>
20
21 using namespace Dali;
22
23 namespace // unnamed namespace
24 {
25
26 const char * const EFFECT_TIME( "ScrollViewTwistEffect::EFFECT_TIME" );
27 const char * const EFFECT_REFERENCE( "ScrollViewTwistEffect::EFFECT_REFERENCE" );
28 const char * const EFFECT_DEPTH( "ScrollViewTwistEffect::EFFECT_DEPTH");
29 const char * const EFFECT_ACTIVATE( "ScrollViewTwistEffect::EFFECT_ACTIVATE");
30
31 const float TWISTEFFECT_ANIMATION_MAX_TIME = 60.0f;         ///< Animation time (every time finishes, checks if it needs to go again)
32 const float TWISTEFFECT_DEFAULT_DROPOFF = 0.7f;             ///< Default drop off amount
33 const float TWISTEFFECT_DEFAULT_DROPOFF_DISTANCE_X = 720.0f;  ///< Default drop off distance
34 const float TWISTEFFECT_DEFAULT_DROPOFF_DISTANCE_Y = 1280.0f;  ///< Default drop off distance
35
36 // Hop Easing equation.
37 // Starts with a -ve cosine ranging from 0 to pi.
38 // Then plateaus.
39 // Then finishes with a -ve cosine ranging from pi to 0
40 // 0......(RISE).....PI (SUSTAIN) PI.....(FALL)......0
41 //                xxxxxxxxxxxxxxxxxxxxx
42 //              x                       x
43 //            x                           x
44 //           x                             x
45 //           x                             x
46 //          x                               x
47 //        x                                   x
48 // xxxxxx                                       xxxxxx
49
50 const float HOP_RISE(0.25f);
51 const float HOP_FALL(0.5f);
52 const float DELAY(0.5f);
53
54 float HopEasing(float progress)
55 {
56   // progress from 0.0 - HOP_RISE (go from 0.0 to 1.0)
57   if(progress < HOP_RISE)
58   {
59     return 0.5f - cosf(progress/HOP_RISE * Math::PI) * 0.5f;
60   }
61
62   progress += HOP_FALL - 1.0f;
63
64   // progress from 0.0 - HOP_FALL (go from 1.0 to 0.0)
65   if(progress > 0.0f )
66   {
67     return 0.5f + cosf(progress/HOP_FALL * Math::PI) * 0.5f;
68   }
69
70   // progress at plateau.
71   return 1.0f;
72 }
73
74 /**
75  * Gets a property index. If the property doesn't already exist, then
76  * it will create the property.
77  * @param[in] handle The handle that owns or will own the property
78  * @param[in] name The name for this property
79  * @param[in] propertyValue The initial value for this property
80  * @return The property index for this property is returned.
81  */
82 Property::Index SafeRegisterProperty( Handle& handle, const std::string& name, Property::Value propertyValue )
83 {
84   Property::Index index = handle.GetPropertyIndex( name );
85
86   if(index == Property::INVALID_INDEX)
87   {
88     index = handle.RegisterProperty( name, propertyValue );
89   }
90
91   return index;
92 }
93
94 /**
95  * Re-scales input value x from x0 - x1, to linearly map
96  * over the values y0 - y1. Values outside of this range
97  * will also conform to the trend (gradient) set.
98  * @param[in] x input X value
99  * @param[in] x0 input minimum bound
100  * @param[in] x1 input maximum bound
101  * @param[in] y0 output minimum bound
102  * @param[in] y1 output maximum bound
103  * @return The result of the mapping is returned.
104  */
105 float Rescale(float x, float x0, float x1, float y0, float y1)
106 {
107   return y0 + (y1 - y0) * (x - x0) / (x1-x0);
108 }
109
110 /**
111  * Returns the value of x chasing target.
112  * returns a value of x which is closer to target.
113  * but limited by maxDelta. #
114  * For example:
115  * x = 10.0f
116  * target = 50.0f
117  * maxDelta = 20.0f
118  * result is 30.0f (x is 20.0f units closer to target)
119  * However, if x is already within maxDelta units
120  * of target, x will equal target.
121  * For example:
122  * x = 55.0f
123  * target = 50.0f
124  * maxDelta = 20.0f
125  * result is 50.0f (x was already within 20.0f units of target)
126  */
127 float Chase( float x, float target, float maxDelta )
128 {
129   float delta = target - x;
130
131   if(delta > 0.0f)
132   {
133     x = std::min( x + maxDelta, target );
134   }
135   else
136   {
137     x = std::max( x - maxDelta, target );
138   }
139
140   return x;
141 }
142
143 // constraints ////////////////////////////////////////////////////////////////
144
145 /**
146  * ScrollTwistRotationConstraint
147  *
148  * Rotate constraint adjusts the angle of the Actors
149  * based on actor's world-position relative to the middle of the screen.
150  * When at middle of screen Angles on X and Y Axes is 0.
151  * When one screen away from the middle Angle is 90 degrees (pi/2)
152  */
153 struct ScrollDropoffTwistRotationConstraint
154 {
155   /**
156    * Constraint constructor
157    * @param[in] angleSwing The amount the Actor should revolve in radians
158    * for a given page worth of distance.
159    */
160   ScrollDropoffTwistRotationConstraint(const Vector2& angleSwing, const Vector2& dropOff, const Vector2& distance, AlphaFunction function)
161   : mAngleSwing(angleSwing),
162     mDropOff(dropOff),
163     mDropOffDistance(distance),
164     mDropOffFunction(function)
165   {
166   }
167
168   /**
169    * @param[in] current The current orientation of this Actor
170    * @param[in] actorPositionProperty The actor's world-position property
171    * @param[in] scrollOvershootXProperty The scroll-view's overshoot property (SCROLL_OVERSHOOT_X_PROPERTY_NAME)
172    * @param[in] scrollOvershootYProperty The scroll-view's overshoot property (SCROLL_OVERSHOOT_Y_PROPERTY_NAME)
173    * @param[in] pageSizeProperty The size of the page. (scrollView SIZE)
174    * @return The new orientation of this Actor.
175    */
176   Quaternion operator()(const Quaternion& current,
177                         const PropertyInput& actorPositionProperty,
178                         const PropertyInput& scrollablePositionProperty,
179                         const PropertyInput& scrollOvershootXProperty,
180                         const PropertyInput& scrollOvershootYProperty,
181                         const PropertyInput& pageSizeProperty,
182                         const PropertyInput& activateProperty)
183   {
184     const Vector3& position = actorPositionProperty.GetVector3();
185     const Vector3& parentPosition = scrollablePositionProperty.GetVector3();
186     const Vector3& pageSize = pageSizeProperty.GetVector3();
187     const Vector2 overshoot(scrollOvershootXProperty.GetFloat(), scrollOvershootYProperty.GetFloat());
188
189     if(fabsf(overshoot.x) < Math::MACHINE_EPSILON_0 && fabsf(overshoot.y) < Math::MACHINE_EPSILON_0)
190     {
191       return current;
192     }
193
194     const float& activate = activateProperty.GetFloat();
195
196     if(activate < Math::MACHINE_EPSILON_0)
197     {
198       return current;
199     }
200
201     // get distance from centre of scrollable container
202     Vector2 distance = position.GetVectorXY() - parentPosition.GetVectorXY();
203
204     if( overshoot.x > 0.0f )
205     {
206       distance.x += pageSize.x * 0.5f;
207     }
208     else
209     {
210       distance.x -= pageSize.x * 0.5f;
211     }
212     distance.x = Clamp(fabsf(distance.x), 0.0f, mDropOffDistance.x);
213
214     if( overshoot.y > 0.0f )
215     {
216       distance.y += pageSize.y * 0.5f;
217     }
218     else
219     {
220       distance.y -= pageSize.y * 0.5f;
221     }
222     distance.y = Clamp(fabsf(distance.y), 0.0f, mDropOffDistance.y);
223
224     Vector2 angleMod = distance / mDropOffDistance;
225     if(mDropOffFunction)
226     {
227       angleMod.x = mDropOffFunction(angleMod.x);
228       angleMod.y = mDropOffFunction(angleMod.y);
229     }
230     angleMod = Vector2::ONE - (angleMod * mDropOff);
231
232     Vector2 angle = angleMod * mAngleSwing * overshoot;
233
234     Quaternion rotation = Quaternion(angle.x, Vector3::YAXIS) *
235                           Quaternion(-angle.y, Vector3::XAXIS) *
236                           current;
237
238     return rotation;
239   }
240
241   const Vector2 mAngleSwing;                                    ///< Maximum amount in X and Y axes to rotate.
242   const Vector2 mDropOff;
243   const Vector2 mDropOffDistance;
244   AlphaFunction mDropOffFunction;
245 };
246
247 /**
248  * ScrollTwistRotationConstraint
249  *
250  * Rotate constraint adjusts the angle of the Actors
251  * based on actor's world-position relative to the middle of the screen.
252  * When at middle of screen Angles on X and Y Axes is 0.
253  * When one screen away from the middle Angle is 90 degrees (pi/2)
254  */
255 struct ScrollTwistRotationConstraint
256 {
257   /**
258    * Constraint constructor
259    * @param[in] angleSwing The amount the Actor should revolve in radians
260    * for a given page worth of distance.
261    */
262   ScrollTwistRotationConstraint(const Vector2& angleSwing)
263   : mAngleSwing(angleSwing)
264   {
265   }
266
267   /**
268    * @param[in] current The current orientation of this Actor
269    * @param[in] actorPositionProperty The actor's world-position property
270    * @param[in] scrollOvershootXProperty The scroll-view's overshoot property (SCROLL_OVERSHOOT_X_PROPERTY_NAME)
271    * @param[in] scrollOvershootYProperty The scroll-view's overshoot property (SCROLL_OVERSHOOT_Y_PROPERTY_NAME)
272    * @param[in] pageSizeProperty The size of the page. (scrollView SIZE)
273    * @return The new orientation of this Actor.
274    */
275   Quaternion operator()(const Quaternion& current,
276                         const PropertyInput& scrollOvershootXProperty,
277                         const PropertyInput& scrollOvershootYProperty,
278                         const PropertyInput& activateProperty)
279   {
280     const Vector2 overshoot(scrollOvershootXProperty.GetFloat(), scrollOvershootYProperty.GetFloat());
281
282     if(fabsf(overshoot.x) < Math::MACHINE_EPSILON_0 && fabsf(overshoot.y) < Math::MACHINE_EPSILON_0)
283     {
284       return current;
285     }
286
287     const float& activate = activateProperty.GetFloat();
288
289     if(activate < Math::MACHINE_EPSILON_0)
290     {
291       return current;
292     }
293
294     Quaternion rotation = Quaternion(overshoot.x * mAngleSwing.x, Vector3::YAXIS) *
295                           Quaternion(-overshoot.y * mAngleSwing.y, Vector3::XAXIS) *
296                           current;
297
298     return rotation;
299   }
300
301   const Vector2 mAngleSwing;
302 };
303
304 /**
305  * ScrollTwistPositionConstraint
306  *
307  * Position constraint adjusts the position of the Actors
308  * based on their parent page's position relative to the middle of the screen.
309  * When at middle of the screen the position is not altered.
310  * When one screen away from middle the position is rotated about it's origin + mAnchor
311  */
312 struct ScrollTwistPositionConstraint
313 {
314   /**
315    * Constraint constructor
316    */
317   ScrollTwistPositionConstraint(float delayMin, float delayMax)
318   : mDelayMin(delayMin),
319     mDelayMax(delayMax),
320     mCurrentDelayFactor(0.0f)
321   {
322   }
323
324   /**
325    * @param[in] current The current position
326    * @param[in] scrollPositionProperty The scroll-view's position property (SCROLL_POSITION_PROPERTY_NAME)
327    * @param[in] effectReferenceProperty The point in the scroll-view where the user touched the screen
328    * @param[in] effectTimeProperty The current timer. Starting from 0.0 when scroll animation/dragging
329    * commences. Ensures that constraint is applied and processed every frame (to achieve the delay effect)
330    * @param[in] sizeProperty The size of the ScrollView.
331    * @return The new position of this Actor.
332    */
333   Vector3 operator()(const Vector3& current,
334                      const PropertyInput& pagePositionProperty,
335                      const PropertyInput& scrollPositionProperty,
336                      const PropertyInput& effectReferenceProperty,
337                      const PropertyInput& effectTimeProperty,
338                      const PropertyInput& sizeProperty,
339                      const PropertyInput& activateProperty)
340   {
341     const Vector3& scrollPosition = scrollPositionProperty.GetVector3();
342     const float& activate = activateProperty.GetFloat();
343
344     if(activate < Math::MACHINE_EPSILON_0)
345     {
346       mScrollPosition = scrollPosition;
347       return current + mScrollPosition;
348     }
349     const Vector3& pagePosition = pagePositionProperty.GetVector3();
350     const Vector3& referencePoint = effectReferenceProperty.GetVector3();
351     // Determine the relative position of the actor from the scrolling reference point.
352     // (the further away from the refernce, the longer the delay should be)
353     Vector3 relativePosition = pagePosition + current - referencePoint;
354     float f = relativePosition.x;
355
356     // f represents this absolute distance. Get as a relative distance and inverse exponential
357     // (as delay equation is has an exponential effect i.e. the closer delayFactor to 1.0f,
358     // the longer the delay would appear exponentially)
359     f = fabsf(f / sizeProperty.GetVector3().width);
360     f = std::min(f, 1.0f);
361     f = 1.0f - (1.0f - f) * (1.0f - f);
362     // at center delay factor is mDelayMin, at maximum (1.0) it is mDelayMax
363     f = Rescale(f, 0.0f, 1.0f, mDelayMin, mDelayMax);
364
365     // Will take 0.25s for current delay factor to equal target delay factor
366     // This prevents users quickly dragging from different points and noticing a jerk.
367     mCurrentDelayFactor = Chase( mCurrentDelayFactor, f, 4.0f/60.0f );
368     float delay = activate * mCurrentDelayFactor;
369     mScrollPosition = mScrollPosition * delay + scrollPosition * (1.0f-delay);
370
371     return current + mScrollPosition;
372   }
373
374 private:
375
376   Vector3 mScrollPosition;              ///< The current scroll position
377   float mDelayMin;
378   float mDelayMax;
379   float mCurrentDelayFactor;
380
381 };
382
383 /**
384  * ScrollTwistScaleConstraint
385  *
386  * Scale constraint adjusts the scale of the Actors
387  * based on a supplied depth property value.
388  */
389 struct ScrollTwistScaleConstraint
390 {
391   /**
392    * Constraint constructor
393    */
394   ScrollTwistScaleConstraint(float scaleAmount)
395   : mScaleAmount(scaleAmount)
396   {
397   }
398
399   /**
400    * @param[in] current The current position
401    * @param[in] scrollPositionProperty The scroll-view's position property (SCROLL_POSITION_PROPERTY_NAME)
402    * @return The new position of this Actor.
403    */
404   Vector3 operator()(const Vector3& current,
405                      const PropertyInput& depthProperty)
406   {
407     float depth = depthProperty.GetFloat();
408
409     return current * (1.0f - depth * mScaleAmount); // contract by mScaleAmount of original size.
410   }
411
412 private:
413
414   float mScaleAmount;
415 };
416
417 } // unnamed namespace
418
419 namespace Dali
420 {
421
422 namespace Toolkit
423 {
424
425 namespace Internal
426 {
427
428 ScrollViewTwistEffect::ScrollViewTwistEffect()
429 : mFlags(DefaultFlags),
430   mPropertyTime(Property::INVALID_INDEX),
431   mEnableEffect(true),
432   mAdditionalEffects(false),
433   mPropertyReference(Property::INVALID_INDEX),
434   mPropertyActivate(Property::INVALID_INDEX),
435   mMinimumDistanceForShrink(Toolkit::ScrollViewTwistEffect::DEFAULT_MINIMUM_DISTANCE_FOR_SHRINK),
436   mMaxSwingAngle(Math::PI_2, Math::PI_2),
437   mDropOff(TWISTEFFECT_DEFAULT_DROPOFF, TWISTEFFECT_DEFAULT_DROPOFF),
438   mDropOffDistance(TWISTEFFECT_DEFAULT_DROPOFF_DISTANCE_X, TWISTEFFECT_DEFAULT_DROPOFF_DISTANCE_Y),
439   mDropOffFunction(NULL)
440 {
441 }
442
443 ScrollViewTwistEffect::~ScrollViewTwistEffect()
444 {
445 }
446
447
448 float ScrollViewTwistEffect::GetMinimumDistanceForShrink() const
449 {
450   return mMinimumDistanceForShrink;
451 }
452
453 void ScrollViewTwistEffect::SetMinimumDistanceForShrink(float distance)
454 {
455   mMinimumDistanceForShrink = distance;
456 }
457
458 void ScrollViewTwistEffect::EnableEffect(bool enableFlag)
459 {
460   mEnableEffect = enableFlag;
461 }
462
463 void ScrollViewTwistEffect::ApplyToActor(Actor child,
464                                          bool additionalEffects,
465                                          const Vector2& angleSwing,
466                                          float scaleAmount,
467                                          float delayMin,
468                                          float delayMax)
469 {
470   mMaxSwingAngle = angleSwing;
471   mAdditionalEffects = additionalEffects;
472   mScaleFactor = scaleAmount;
473   mDelayMin = delayMin;
474   mDelayMax = delayMax;
475   if(mFlags & FlagDefaultDropOff)
476   {
477     Vector3 size = GetScrollView().GetCurrentSize();
478     // size may still be 0 if the effect is applied before scroll view hits the stage
479     if(size.x > Math::MACHINE_EPSILON_1)
480     {
481       mDropOffDistance.x = size.x;
482     }
483     if(size.y > Math::MACHINE_EPSILON_1)
484     {
485       mDropOffDistance.y = size.y;
486     }
487   }
488   if(scaleAmount > Math::MACHINE_EPSILON_0)
489   {
490     mFlags |= FlagScale;
491   }
492   else
493   {
494     mFlags = mFlags & ~FlagScale;
495   }
496   if(mMaxSwingAngle.LengthSquared() > Math::MACHINE_EPSILON_0)
497   {
498     mFlags |= FlagTwist;
499   }
500   else
501   {
502     mFlags = mFlags & ~FlagTwist;
503   }
504   Apply(child);
505 }
506
507 void ScrollViewTwistEffect::Apply(Actor child)
508 {
509   // Apply constraints to these actors //
510   Constraint constraint;
511
512   Toolkit::ScrollView scrollView = GetScrollView();
513
514   if( mFlags & FlagScale )
515   {
516     constraint = Constraint::New<Vector3>( Actor::SCALE,
517                                            Source(scrollView, scrollView.GetPropertyIndex( EFFECT_DEPTH ) ),
518                                            ScrollTwistScaleConstraint(mScaleFactor) );
519     constraint.SetRemoveAction( Constraint::Discard );
520     child.ApplyConstraint( constraint );
521   }
522
523   constraint = Constraint::New<Vector3>( Actor::POSITION,
524                                           ParentSource(Actor::POSITION),
525                                           Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_POSITION_PROPERTY_NAME ) ),
526                                           Source(scrollView, scrollView.GetPropertyIndex( EFFECT_REFERENCE ) ),
527                                           Source(scrollView, scrollView.GetPropertyIndex( EFFECT_TIME ) ),
528                                           Source(scrollView, Actor::SIZE),
529                                           Source(scrollView, scrollView.GetPropertyIndex( EFFECT_ACTIVATE) ),
530                                          ScrollTwistPositionConstraint(mDelayMin, mDelayMax) );
531   constraint.SetRemoveAction( Constraint::Discard );
532   child.ApplyConstraint( constraint );
533
534   // use actor position to affect rotation
535   if(mFlags & FlagTwist)
536   {
537     if(mFlags & FlagDropOff)
538     {
539       constraint = Constraint::New<Quaternion>( Actor::ROTATION,
540                                                 LocalSource(Actor::WORLD_POSITION),
541                                                 Source(scrollView, Actor::WORLD_POSITION ),
542                                                 Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_OVERSHOOT_X_PROPERTY_NAME ) ),
543                                                 Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_OVERSHOOT_Y_PROPERTY_NAME ) ),
544                                                 Source(scrollView, Actor::SIZE ),
545                                                 Source(scrollView, scrollView.GetPropertyIndex( EFFECT_ACTIVATE) ),
546                                                 ScrollDropoffTwistRotationConstraint(mMaxSwingAngle, mDropOff, mDropOffDistance, mDropOffFunction) );
547     }
548     else
549     {
550       constraint = Constraint::New<Quaternion>( Actor::ROTATION,
551                                                 Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_OVERSHOOT_X_PROPERTY_NAME ) ),
552                                                 Source(scrollView, scrollView.GetPropertyIndex( Toolkit::ScrollView::SCROLL_OVERSHOOT_Y_PROPERTY_NAME ) ),
553                                                 Source(scrollView, scrollView.GetPropertyIndex( EFFECT_ACTIVATE) ),
554                                                 ScrollTwistRotationConstraint(mMaxSwingAngle) );
555     }
556     constraint.SetRemoveAction( Constraint::Discard );
557     child.ApplyConstraint( constraint );
558   }
559 }
560
561 void ScrollViewTwistEffect::SetSwingDropOff(const Vector2& dropOff, const Vector2& distance, AlphaFunction function)
562 {
563   if( mDropOffDistance.LengthSquared() > Math::MACHINE_EPSILON_1 && mDropOff.LengthSquared() > Math::MACHINE_EPSILON_1 )
564   {
565     mFlags |= FlagDropOff;
566     mDropOff = dropOff;
567     mDropOffDistance = distance;
568     mDropOffFunction = function;
569   }
570   else
571   {
572     mFlags = mFlags & ~FlagDropOff;
573   }
574   // can no longer use default dop off
575   mFlags = mFlags & ~FlagDefaultDropOff;
576 }
577
578 void ScrollViewTwistEffect::OnAttach(Toolkit::ScrollView& scrollView)
579 {
580   // Create effect-time property if not already created.
581   if(mPropertyTime == Property::INVALID_INDEX)
582   {
583     mPropertyTime = SafeRegisterProperty( scrollView, EFFECT_TIME, 0.0f );
584     mPropertyReference = SafeRegisterProperty( scrollView, EFFECT_REFERENCE, Vector3::ZERO );
585     mPropertyDepth = SafeRegisterProperty( scrollView, EFFECT_DEPTH, 0.0f);
586     mPropertyActivate = SafeRegisterProperty(scrollView, EFFECT_ACTIVATE, 1.0f);
587   }
588
589   // Connect to the scroll view signals
590   scrollView.ScrollStartedSignal().Connect(this, &ScrollViewTwistEffect::OnScrollStart);
591   scrollView.SnapStartedSignal().Connect(this, &ScrollViewTwistEffect::OnScrollSnap);
592   scrollView.ScrollUpdatedSignal().Connect(this, &ScrollViewTwistEffect::OnScrollUpdate);
593   scrollView.ScrollCompletedSignal().Connect(this, &ScrollViewTwistEffect::OnScrollComplete);
594
595   AttachActor(scrollView);
596 }
597
598 void ScrollViewTwistEffect::OnDetach(Toolkit::ScrollView& scrollView)
599 {
600   scrollView.ScrollStartedSignal().Disconnect(this, &ScrollViewTwistEffect::OnScrollStart);
601   scrollView.SnapStartedSignal().Disconnect(this, &ScrollViewTwistEffect::OnScrollSnap);
602   scrollView.ScrollUpdatedSignal().Disconnect(this, &ScrollViewTwistEffect::OnScrollUpdate);
603   scrollView.ScrollCompletedSignal().Disconnect(this, &ScrollViewTwistEffect::OnScrollComplete);
604
605   if(mAnimation)
606   {
607     mAnimation.FinishedSignal().Disconnect(this, &ScrollViewTwistEffect::OnAnimationFinished);
608     mAnimation.Clear();
609     mAnimation.Reset();
610   }
611 }
612
613 void ScrollViewTwistEffect::AttachActor(Actor actor)
614 {
615
616 }
617
618 void ScrollViewTwistEffect::DetachActor(Actor actor)
619 {
620   // TODO: remove the specific constraint defined in AttachActor (and possibly
621   // unregister property) - neither functionality exists in Dali.
622 }
623
624 void ScrollViewTwistEffect::ContinueAnimation(float endTime)
625 {
626   // continue animating
627   if(mAnimation)
628   {
629     mAnimation.FinishedSignal().Disconnect(this, &ScrollViewTwistEffect::OnAnimationFinished);
630     mAnimation.Clear();
631   }
632
633   Actor scrollView = GetScrollView();
634
635   mAnimation = Animation::New(TWISTEFFECT_ANIMATION_MAX_TIME);
636   mAnimation.AnimateTo( Property(scrollView, mPropertyTime), endTime, AlphaFunctions::Linear );
637   mAnimation.FinishedSignal().Connect(this, &ScrollViewTwistEffect::OnAnimationFinished);
638   mAnimation.Play();
639 }
640
641 void ScrollViewTwistEffect::OnScrollStart( const Vector3& position )
642 {
643   if(mActivateAnimation)
644   {
645     // if the animation after Scroll complete not terminate before another scroll action, stop the animation before start again
646     mActivateAnimation.Stop();
647     mActivateAnimation.Clear();
648     mActivateAnimation = NULL;
649   }
650
651   GetScrollView().SetProperty(mPropertyTime, 0.0f);
652   if(mEnableEffect)
653   {
654     GetScrollView().SetProperty(mPropertyActivate, 1.0f);
655   }
656   else
657   {
658     GetScrollView().SetProperty(mPropertyActivate, 0.0f);
659   }
660   GetScrollView().SetProperty(mPropertyReference, position);
661
662   ContinueAnimation(TWISTEFFECT_ANIMATION_MAX_TIME);
663 }
664
665 void ScrollViewTwistEffect::OnScrollUpdate( const Vector3& position )
666 {
667   // nothing to do
668 }
669
670 void ScrollViewTwistEffect::OnScrollComplete( const Vector3& position )
671 {
672   if(!mEnableEffect)
673   {
674     OnActivateAnimationFinished(mAnimation);
675     return;
676   }
677   Actor scrollView = GetScrollView();
678   scrollView.SetProperty(mPropertyActivate, 1.0f);
679   mActivateAnimation = Animation::New(DELAY);
680   mActivateAnimation.AnimateTo( Property(scrollView, mPropertyActivate), 0.0f, AlphaFunctions::Linear);
681   mActivateAnimation.FinishedSignal().Connect(this, &ScrollViewTwistEffect::OnActivateAnimationFinished);
682   mActivateAnimation.Play();
683 }
684
685 void ScrollViewTwistEffect::OnScrollSnap( const Toolkit::ScrollView::SnapEvent& event )
686 {
687   // If a Flicking snap is occuring and the distance is more than mMinimumDistanceForShrink
688   // then animate depth effect i.e. shrink actors and then bring back in to regular size.
689   // NOTE: ScrollView Snap returns a value opposite of GetCurrentScrollPosition
690   // i.e. if you've "scrolled 100 pixels right" (so content on screen has shifted 100 pixels left)
691   // then GetCurrentScrollPosition returns a positive value (100.0f, 0.0f) (position of where you're
692   // look, not where content has been moved to).
693   // event.position returns a negative value (-100.0f, 0.0f)
694   // Would be a good idea to change SnapEvent in the API so it reflects GetCurrentScrollPosition.
695   // TODO: Change scroll-view API, check if anything uses SnapEvent and change them correspondingly
696   Vector3 targetScrollPosition(-event.position);
697
698   Vector3 delta = targetScrollPosition - GetScrollView().GetCurrentScrollPosition();
699
700   if(event.type==Flick && delta.Length() > mMinimumDistanceForShrink)
701   {
702     Actor scrollView = GetScrollView();
703
704     Animation animation = Animation::New(event.duration);
705     animation.AnimateTo( Property(scrollView, mPropertyDepth), 1.0f, HopEasing);
706     animation.Play();
707   }
708 }
709
710 void ScrollViewTwistEffect::OnAnimationFinished( Animation& animation )
711 {
712   // still unstable, so continue animating.
713   // TODO: Requires an instability check to ensure time animation finishes when delay is
714   // less noticeable. i.e. all present scrollPositions are approx the same as mScrollPosition in constraints.
715   // best solution for this is to switch to a single history vector of scroll position, and compare if
716   // position has not deviated >= 0.5 pixel for the past 1 second.
717   float endTime = GetScrollView().GetProperty<float>(mPropertyTime) + TWISTEFFECT_ANIMATION_MAX_TIME;
718   ContinueAnimation(endTime);
719 }
720
721 void ScrollViewTwistEffect::OnActivateAnimationFinished( Animation& animation )
722 {
723   if(mAnimation)
724   {
725     mAnimation.FinishedSignal().Disconnect(this, &ScrollViewTwistEffect::OnAnimationFinished);
726     mAnimation.Clear();
727     mAnimation.Reset();
728   }
729 }
730
731
732 } // namespace Internal
733
734 } // namespace Toolkit
735
736 } // namespace Dali