Remove last reference to boost in dali-core
[platform/core/uifw/dali-core.git] / dali / internal / event / animation / animation-impl.cpp
1 /*
2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
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
18 // CLASS HEADER
19 #include <dali/internal/event/animation/animation-impl.h>
20
21 // EXTERNAL INCLUDES
22 #include <cstring> // for strcmp
23
24 // INTERNAL INCLUDES
25 #include <dali/public-api/actors/actor.h>
26 #include <dali/public-api/animation/alpha-functions.h>
27 #include <dali/public-api/animation/time-period.h>
28 #include <dali/public-api/common/dali-common.h>
29 #include <dali/public-api/object/type-registry.h>
30 #include <dali/public-api/math/vector2.h>
31 #include <dali/public-api/math/radian.h>
32 #include <dali/internal/event/actors/actor-impl.h>
33 #include <dali/internal/event/animation/animation-playlist.h>
34 #include <dali/internal/event/animation/animator-connector.h>
35 #include <dali/internal/event/common/notification-manager.h>
36 #include <dali/internal/event/common/property-helper.h>
37 #include <dali/internal/event/common/stage-impl.h>
38 #include <dali/internal/event/common/thread-local-storage.h>
39 #include <dali/internal/event/effects/shader-effect-impl.h>
40 #include <dali/internal/update/manager/update-manager.h>
41
42 using Dali::Internal::SceneGraph::UpdateManager;
43 using Dali::Internal::SceneGraph::AnimatorBase;
44 using Dali::Internal::SceneGraph::Shader;
45
46 namespace Dali
47 {
48
49 namespace Internal
50 {
51
52 static bool SHOW_VALUE = true;
53 static bool HIDE_VALUE = false;
54
55 namespace
56 {
57
58 // Signals
59
60 const char* const SIGNAL_FINISHED = "finished";
61
62 // Actions
63
64 const char* const ACTION_PLAY =     "play";
65 const char* const ACTION_STOP =     "stop";
66 const char* const ACTION_PAUSE =    "pause";
67
68 BaseHandle Create()
69 {
70   return Dali::Animation::New(0.f);
71 }
72
73 TypeRegistration mType( typeid( Dali::Animation ), typeid( Dali::BaseHandle ), Create );
74
75 SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &Animation::DoConnectSignal );
76
77 TypeAction action1( mType, ACTION_PLAY,  &Animation::DoAction );
78 TypeAction action2( mType, ACTION_STOP,  &Animation::DoAction );
79 TypeAction action3( mType, ACTION_PAUSE, &Animation::DoAction );
80
81 const Dali::Animation::EndAction DEFAULT_END_ACTION( Dali::Animation::Bake );
82 const Dali::Animation::EndAction DEFAULT_DISCONNECT_ACTION( Dali::Animation::BakeFinal );
83 const Dali::Animation::Interpolation DEFAULT_INTERPOLATION( Dali::Animation::Linear );
84
85 } // anon namespace
86
87
88 AnimationPtr Animation::New(float durationSeconds)
89 {
90   Stage* stage = Stage::GetCurrent();
91
92   AnimationPlaylist& playlist = stage->GetAnimationPlaylist();
93
94   AnimationPtr animation = new Animation( *stage, playlist, durationSeconds, DEFAULT_END_ACTION, DEFAULT_DISCONNECT_ACTION, Dali::AlphaFunctions::Linear );
95
96   // Second-phase construction
97   animation->Initialize();
98
99   return animation;
100 }
101
102 Animation::Animation( EventThreadServices& eventThreadServices, AnimationPlaylist& playlist, float durationSeconds, EndAction endAction, EndAction disconnectAction, AlphaFunction defaultAlpha )
103 : mEventThreadServices( eventThreadServices ),
104   mPlaylist( playlist ),
105   mAnimation( NULL ),
106   mNotificationCount( 0 ),
107   mFinishedCallback( NULL ),
108   mFinishedCallbackObject( NULL ),
109   mDurationSeconds( durationSeconds ),
110   mSpeedFactor(1.0f),
111   mIsLooping( false ),
112   mPlayRange( Vector2(0.0f,1.0f)),
113   mEndAction( endAction ),
114   mDisconnectAction( disconnectAction ),
115   mDefaultAlpha( defaultAlpha )
116 {
117 }
118
119 void Animation::Initialize()
120 {
121   // Connect to the animation playlist
122   mPlaylist.AnimationCreated( *this );
123
124   CreateSceneObject();
125
126   RegisterObject();
127 }
128
129 Animation::~Animation()
130 {
131   // Guard to allow handle destruction after Core has been destroyed
132   if ( Stage::IsInstalled() )
133   {
134     // Disconnect from the animation playlist
135     mPlaylist.AnimationDestroyed( *this );
136
137     DestroySceneObject();
138
139     UnregisterObject();
140   }
141 }
142
143 void Animation::CreateSceneObject()
144 {
145   DALI_ASSERT_DEBUG( mAnimation == NULL );
146
147   // Create a new animation, temporarily owned
148   SceneGraph::Animation* animation = SceneGraph::Animation::New( mDurationSeconds, mSpeedFactor, mPlayRange, mIsLooping, mEndAction, mDisconnectAction );
149
150   // Keep a const pointer to the animation.
151   mAnimation = animation;
152
153   // Transfer animation ownership to the update manager through a message
154   AddAnimationMessage( mEventThreadServices.GetUpdateManager(), animation );
155 }
156
157 void Animation::DestroySceneObject()
158 {
159   if ( mAnimation != NULL )
160   {
161     // Remove animation using a message to the update manager
162     RemoveAnimationMessage( mEventThreadServices.GetUpdateManager(), *mAnimation );
163     mAnimation = NULL;
164   }
165 }
166
167 void Animation::SetDuration(float seconds)
168 {
169   // Cache for public getters
170   mDurationSeconds = seconds;
171
172   // mAnimation is being used in a separate thread; queue a message to set the value
173   SetDurationMessage( mEventThreadServices, *mAnimation, seconds );
174 }
175
176 float Animation::GetDuration() const
177 {
178   // This is not animatable; the cached value is up-to-date.
179   return mDurationSeconds;
180 }
181
182 void Animation::SetLooping(bool looping)
183 {
184   // Cache for public getters
185   mIsLooping = looping;
186
187   // mAnimation is being used in a separate thread; queue a message to set the value
188   SetLoopingMessage( mEventThreadServices, *mAnimation, looping );
189 }
190
191 bool Animation::IsLooping() const
192 {
193   // This is not animatable; the cached value is up-to-date.
194   return mIsLooping;
195 }
196
197 void Animation::SetEndAction(EndAction action)
198 {
199   // Cache for public getters
200   mEndAction = action;
201
202   // mAnimation is being used in a separate thread; queue a message to set the value
203   SetEndActionMessage( mEventThreadServices, *mAnimation, action );
204 }
205
206 Dali::Animation::EndAction Animation::GetEndAction() const
207 {
208   // This is not animatable; the cached value is up-to-date.
209   return mEndAction;
210 }
211
212 void Animation::SetDisconnectAction(EndAction action)
213 {
214   // Cache for public getters
215   mDisconnectAction = action;
216
217   // mAnimation is being used in a separate thread; queue a message to set the value
218   SetDisconnectActionMessage( mEventThreadServices, *mAnimation, action );
219 }
220
221 Dali::Animation::EndAction Animation::GetDisconnectAction() const
222 {
223   // This is not animatable; the cached value is up-to-date.
224   return mDisconnectAction;
225 }
226
227 void Animation::Play()
228 {
229   // Update the current playlist
230   mPlaylist.OnPlay( *this );
231
232   // mAnimation is being used in a separate thread; queue a Play message
233   PlayAnimationMessage( mEventThreadServices, *mAnimation );
234 }
235
236 void Animation::PlayFrom( float progress )
237 {
238   if( progress >= mPlayRange.x && progress <= mPlayRange.y )
239   {
240     // Update the current playlist
241     mPlaylist.OnPlay( *this );
242
243     // mAnimation is being used in a separate thread; queue a Play message
244     PlayAnimationFromMessage( mEventThreadServices, *mAnimation, progress );
245   }
246 }
247
248 void Animation::Pause()
249 {
250   // mAnimation is being used in a separate thread; queue a Pause message
251   PauseAnimationMessage( mEventThreadServices, *mAnimation );
252 }
253
254 void Animation::Stop()
255 {
256   // mAnimation is being used in a separate thread; queue a Stop message
257   StopAnimationMessage( mEventThreadServices.GetUpdateManager(), *mAnimation );
258 }
259
260 void Animation::Clear()
261 {
262   DALI_ASSERT_DEBUG(mAnimation);
263
264   // Remove all the connectors
265   mConnectors.Clear();
266
267   // Replace the old scene-object with a new one
268   DestroySceneObject();
269   CreateSceneObject();
270
271   // Reset the notification count, since the new scene-object has never been played
272   mNotificationCount = 0;
273
274   // Update the current playlist
275   mPlaylist.OnClear( *this );
276 }
277
278 void Animation::AnimateBy(Property& target, Property::Value& relativeValue)
279 {
280   AnimateBy(target, relativeValue, AlphaFunctions::Default, mDurationSeconds);
281 }
282
283 void Animation::AnimateBy(Property& target, Property::Value& relativeValue, AlphaFunction alpha)
284 {
285   AnimateBy(target, relativeValue, alpha, mDurationSeconds);
286 }
287
288 void Animation::AnimateBy(Property& target, Property::Value& relativeValue, TimePeriod period)
289 {
290   AnimateBy(target, relativeValue, AlphaFunctions::Default, period);
291 }
292
293 void Animation::AnimateBy(Property& target, Property::Value& relativeValue, AlphaFunction alpha, TimePeriod period)
294 {
295   Object& object = dynamic_cast<Object&>( GetImplementation(target.object) );
296
297   ExtendDuration( period );
298
299   switch ( relativeValue.GetType() )
300   {
301     case Property::BOOLEAN:
302     {
303       AddAnimatorConnector( AnimatorConnector<bool>::New( object,
304                                                           target.propertyIndex,
305                                                           target.componentIndex,
306                                                           new AnimateByBoolean(relativeValue.Get<bool>()),
307                                                           alpha,
308                                                           period ) );
309       break;
310     }
311
312     case Property::FLOAT:
313     {
314       AddAnimatorConnector( AnimatorConnector<float>::New( object,
315                                                            target.propertyIndex,
316                                                            target.componentIndex,
317                                                            new AnimateByFloat(relativeValue.Get<float>()),
318                                                            alpha,
319                                                            period ) );
320       break;
321     }
322
323     case Property::INTEGER:
324     {
325       AddAnimatorConnector( AnimatorConnector<int>::New( object,
326                                                          target.propertyIndex,
327                                                          target.componentIndex,
328                                                          new AnimateByInteger(relativeValue.Get<int>()),
329                                                          alpha,
330                                                          period ) );
331       break;
332     }
333
334     case Property::VECTOR2:
335     {
336       AddAnimatorConnector( AnimatorConnector<Vector2>::New( object,
337                                                              target.propertyIndex,
338                                                              target.componentIndex,
339                                                              new AnimateByVector2(relativeValue.Get<Vector2>()),
340                                                              alpha,
341                                                              period ) );
342       break;
343     }
344
345     case Property::VECTOR3:
346     {
347       AddAnimatorConnector( AnimatorConnector<Vector3>::New( object,
348                                                              target.propertyIndex,
349                                                              target.componentIndex,
350                                                              new AnimateByVector3(relativeValue.Get<Vector3>()),
351                                                              alpha,
352                                                              period ) );
353       break;
354     }
355
356     case Property::VECTOR4:
357     {
358       AddAnimatorConnector( AnimatorConnector<Vector4>::New( object,
359                                                              target.propertyIndex,
360                                                              target.componentIndex,
361                                                              new AnimateByVector4(relativeValue.Get<Vector4>()),
362                                                              alpha,
363                                                              period ) );
364       break;
365     }
366
367     case Property::ROTATION:
368     {
369       AngleAxis angleAxis = relativeValue.Get<AngleAxis>();
370
371       AddAnimatorConnector( AnimatorConnector<Quaternion>::New( object,
372                                                                 target.propertyIndex,
373                                                                 target.componentIndex,
374                                                                 new RotateByAngleAxis(angleAxis.angle, angleAxis.axis),
375                                                                 alpha,
376                                                                 period ) );
377       break;
378     }
379
380     default:
381       DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should never come here
382       break;
383   }
384 }
385
386 void Animation::AnimateTo(Property& target, Property::Value& destinationValue)
387 {
388   AnimateTo(target, destinationValue, AlphaFunctions::Default, mDurationSeconds);
389 }
390
391 void Animation::AnimateTo(Property& target, Property::Value& destinationValue, AlphaFunction alpha)
392 {
393   AnimateTo(target, destinationValue, alpha, mDurationSeconds);
394 }
395
396 void Animation::AnimateTo(Property& target, Property::Value& destinationValue, TimePeriod period)
397 {
398   AnimateTo(target, destinationValue, AlphaFunctions::Default, period);
399 }
400
401 void Animation::AnimateTo(Property& target, Property::Value& destinationValue, AlphaFunction alpha, TimePeriod period)
402 {
403   Object& object = dynamic_cast<Object&>( GetImplementation(target.object) );
404
405   AnimateTo( object, target.propertyIndex, target.componentIndex, destinationValue, alpha, period );
406 }
407
408 void Animation::AnimateTo(Object& targetObject, Property::Index targetPropertyIndex, int componentIndex, Property::Value& destinationValue, AlphaFunction alpha, TimePeriod period)
409 {
410   Property::Type type = targetObject.GetPropertyType(targetPropertyIndex);
411   if(componentIndex != Property::INVALID_COMPONENT_INDEX)
412   {
413     if( type == Property::VECTOR2
414         || type == Property::VECTOR3
415         || type == Property::VECTOR4 )
416     {
417       type = Property::FLOAT;
418     }
419   }
420   DALI_ASSERT_ALWAYS( type == destinationValue.GetType() && "DestinationValue does not match Target Property type" );
421
422   ExtendDuration( period );
423
424   switch (destinationValue.GetType())
425   {
426     case Property::BOOLEAN:
427     {
428       AddAnimatorConnector( AnimatorConnector<bool>::New( targetObject,
429                                                           targetPropertyIndex,
430                                                           componentIndex,
431                                                           new AnimateToBoolean( destinationValue.Get<bool>() ),
432                                                           alpha,
433                                                           period ) );
434       break;
435     }
436
437     case Property::FLOAT:
438     {
439       AddAnimatorConnector( AnimatorConnector<float>::New( targetObject,
440                                                            targetPropertyIndex,
441                                                            componentIndex,
442                                                            new AnimateToFloat( destinationValue.Get<float>() ),
443                                                            alpha,
444                                                            period ) );
445       break;
446     }
447
448     case Property::INTEGER:
449     {
450       AddAnimatorConnector( AnimatorConnector<int>::New( targetObject,
451                                                          targetPropertyIndex,
452                                                          componentIndex,
453                                                          new AnimateToInteger( destinationValue.Get<int>() ),
454                                                          alpha,
455                                                          period ) );
456       break;
457     }
458
459     case Property::VECTOR2:
460     {
461       AddAnimatorConnector( AnimatorConnector<Vector2>::New( targetObject,
462                                                              targetPropertyIndex,
463                                                              componentIndex,
464                                                              new AnimateToVector2( destinationValue.Get<Vector2>() ),
465                                                              alpha,
466                                                              period ) );
467       break;
468     }
469
470     case Property::VECTOR3:
471     {
472       if ( Dali::Actor::Property::SIZE == targetPropertyIndex )
473       {
474         // Test whether this is actually an Actor
475         Actor* maybeActor = dynamic_cast<Actor*>( &targetObject );
476         if ( maybeActor )
477         {
478           // Notify the actor that its size is being animated
479           maybeActor->NotifySizeAnimation( *this, destinationValue.Get<Vector3>() );
480         }
481       }
482
483       AddAnimatorConnector( AnimatorConnector<Vector3>::New( targetObject,
484                                                              targetPropertyIndex,
485                                                              componentIndex,
486                                                              new AnimateToVector3( destinationValue.Get<Vector3>() ),
487                                                              alpha,
488                                                              period ) );
489       break;
490     }
491
492     case Property::VECTOR4:
493     {
494       AddAnimatorConnector( AnimatorConnector<Vector4>::New( targetObject,
495                                                              targetPropertyIndex,
496                                                              componentIndex,
497                                                              new AnimateToVector4( destinationValue.Get<Vector4>() ),
498                                                              alpha,
499                                                              period ) );
500       break;
501     }
502
503     case Property::ROTATION:
504     {
505       AddAnimatorConnector( AnimatorConnector<Quaternion>::New( targetObject,
506                                                                 targetPropertyIndex,
507                                                                 componentIndex,
508                                                                 new RotateToQuaternion( destinationValue.Get<Quaternion>() ),
509                                                                 alpha,
510                                                                 period ) );
511       break;
512     }
513
514     default:
515       DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should never come here
516       break;
517   }
518 }
519
520 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames)
521 {
522   AnimateBetween(target, keyFrames, mDefaultAlpha, mDurationSeconds, DEFAULT_INTERPOLATION );
523 }
524
525 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, Interpolation interpolation )
526 {
527   AnimateBetween(target, keyFrames, mDefaultAlpha, mDurationSeconds, interpolation );
528 }
529
530 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, TimePeriod period)
531 {
532   AnimateBetween(target, keyFrames, mDefaultAlpha, period, DEFAULT_INTERPOLATION);
533 }
534
535 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, TimePeriod period, Interpolation interpolation)
536 {
537   AnimateBetween(target, keyFrames, mDefaultAlpha, period, interpolation);
538 }
539
540 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, AlphaFunction alpha)
541 {
542   AnimateBetween(target, keyFrames, alpha, mDurationSeconds, DEFAULT_INTERPOLATION);
543 }
544
545 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, AlphaFunction alpha, Interpolation interpolation)
546 {
547   AnimateBetween(target, keyFrames, alpha, mDurationSeconds, interpolation);
548 }
549
550 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, AlphaFunction alpha, TimePeriod period)
551 {
552   AnimateBetween(target, keyFrames, alpha, period, DEFAULT_INTERPOLATION);
553 }
554
555 void Animation::AnimateBetween(Property target, const KeyFrames& keyFrames, AlphaFunction alpha, TimePeriod period, Interpolation interpolation)
556 {
557   Object& object = dynamic_cast<Object&>( GetImplementation(target.object) );
558
559   ExtendDuration( period );
560
561   switch(keyFrames.GetType())
562   {
563     case Dali::Property::BOOLEAN:
564     {
565       const KeyFrameBoolean* kf;
566       GetSpecialization(keyFrames, kf);
567       KeyFrameBooleanPtr kfCopy = KeyFrameBoolean::Clone(*kf);
568       AddAnimatorConnector( AnimatorConnector<bool>::New( object,
569                                                           target.propertyIndex,
570                                                           target.componentIndex,
571                                                           new KeyFrameBooleanFunctor(kfCopy),
572                                                           alpha,
573                                                           period ) );
574       break;
575     }
576
577     case Dali::Property::FLOAT:
578     {
579       const KeyFrameNumber* kf;
580       GetSpecialization(keyFrames, kf);
581       KeyFrameNumberPtr kfCopy = KeyFrameNumber::Clone(*kf);
582       AddAnimatorConnector( AnimatorConnector<float>::New( object,
583                                                            target.propertyIndex,
584                                                            target.componentIndex,
585                                                            new KeyFrameNumberFunctor(kfCopy,interpolation),
586                                                            alpha,
587                                                            period ) );
588       break;
589     }
590
591     case Dali::Property::INTEGER:
592     {
593       const KeyFrameInteger* kf;
594       GetSpecialization(keyFrames, kf);
595       KeyFrameIntegerPtr kfCopy = KeyFrameInteger::Clone(*kf);
596       AddAnimatorConnector( AnimatorConnector<int>::New( object,
597                                                          target.propertyIndex,
598                                                          target.componentIndex,
599                                                          new KeyFrameIntegerFunctor(kfCopy,interpolation),
600                                                          alpha,
601                                                          period ) );
602       break;
603     }
604
605     case Dali::Property::VECTOR2:
606     {
607       const KeyFrameVector2* kf;
608       GetSpecialization(keyFrames, kf);
609       KeyFrameVector2Ptr kfCopy = KeyFrameVector2::Clone(*kf);
610       AddAnimatorConnector( AnimatorConnector<Vector2>::New( object,
611                                                              target.propertyIndex,
612                                                              target.componentIndex,
613                                                              new KeyFrameVector2Functor(kfCopy,interpolation),
614                                                              alpha,
615                                                              period ) );
616       break;
617     }
618
619     case Dali::Property::VECTOR3:
620     {
621       const KeyFrameVector3* kf;
622       GetSpecialization(keyFrames, kf);
623       KeyFrameVector3Ptr kfCopy = KeyFrameVector3::Clone(*kf);
624       AddAnimatorConnector( AnimatorConnector<Vector3>::New( object,
625                                                              target.propertyIndex,
626                                                              target.componentIndex,
627                                                              new KeyFrameVector3Functor(kfCopy,interpolation),
628                                                              alpha,
629                                                              period ) );
630       break;
631     }
632
633     case Dali::Property::VECTOR4:
634     {
635       const KeyFrameVector4* kf;
636       GetSpecialization(keyFrames, kf);
637       KeyFrameVector4Ptr kfCopy = KeyFrameVector4::Clone(*kf);
638       AddAnimatorConnector( AnimatorConnector<Vector4>::New( object,
639                                                              target.propertyIndex,
640                                                              target.componentIndex,
641                                                              new KeyFrameVector4Functor(kfCopy,interpolation),
642                                                              alpha,
643                                                              period ) );
644       break;
645     }
646
647     case Dali::Property::ROTATION:
648     {
649       const KeyFrameQuaternion* kf;
650       GetSpecialization(keyFrames, kf);
651       KeyFrameQuaternionPtr kfCopy = KeyFrameQuaternion::Clone(*kf);
652       AddAnimatorConnector( AnimatorConnector<Quaternion>::New( object,
653                                                                 target.propertyIndex,
654                                                                 target.componentIndex,
655                                                                 new KeyFrameQuaternionFunctor(kfCopy),
656                                                                 alpha,
657                                                                 period ) );
658       break;
659     }
660
661     default: // not all property types are animateable
662       break;
663   }
664 }
665
666 bool Animation::HasFinished()
667 {
668   bool hasFinished(false);
669   const int playCount(mAnimation->GetPlayCount());
670
671   // If the play count has been incremented, then another notification is required
672   if (playCount > mNotificationCount)
673   {
674     // Note that only one signal is emitted, if the animation has been played repeatedly
675     mNotificationCount = playCount;
676
677     hasFinished = true;
678   }
679
680   return hasFinished;
681 }
682
683 Dali::Animation::AnimationSignalType& Animation::FinishedSignal()
684 {
685   return mFinishedSignal;
686 }
687
688 void Animation::EmitSignalFinish()
689 {
690   if ( !mFinishedSignal.Empty() )
691   {
692     Dali::Animation handle( this );
693     mFinishedSignal.Emit( handle );
694   }
695
696   // This callback is used internally, to avoid the overhead of using a signal.
697   if ( mFinishedCallback )
698   {
699     mFinishedCallback( mFinishedCallbackObject );
700   }
701 }
702
703 bool Animation::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
704 {
705   bool connected( true );
706   Animation* animation = dynamic_cast<Animation*>(object);
707
708   if ( 0 == strcmp( signalName.c_str(), SIGNAL_FINISHED ) )
709   {
710     animation->FinishedSignal().Connect( tracker, functor );
711   }
712   else
713   {
714     // signalName does not match any signal
715     connected = false;
716   }
717
718   return connected;
719 }
720
721 void Animation::SetFinishedCallback( FinishedCallback callback, Object* object )
722 {
723   mFinishedCallback = callback;
724   mFinishedCallbackObject = object;
725 }
726
727 void Animation::AddAnimatorConnector( AnimatorConnectorBase* connector )
728 {
729   DALI_ASSERT_DEBUG( NULL != connector );
730
731   connector->SetParent(*this);
732
733   mConnectors.PushBack( connector );
734 }
735
736 void Animation::Animate( Actor& actor, const Path& path, const Vector3& forward )
737 {
738   Animate( actor, path, forward, mDefaultAlpha, TimePeriod(0.0f,GetDuration()) );
739 }
740
741 void Animation::Animate( Actor& actor, const Path& path, const Vector3& forward, AlphaFunction alpha )
742 {
743   Animate( actor, path, forward, alpha, TimePeriod(0.0f,GetDuration()) );
744 }
745
746 void Animation::Animate( Actor& actor, const Path& path, const Vector3& forward, TimePeriod period )
747 {
748   Animate( actor, path, forward, mDefaultAlpha, period );
749 }
750
751 void Animation::Animate( Actor& actor, const Path& path, const Vector3& forward, AlphaFunction alpha, TimePeriod period)
752 {
753   ExtendDuration( period );
754
755   PathPtr pathCopy = Path::Clone(path);
756
757   //Position animation
758   AddAnimatorConnector( AnimatorConnector<Vector3>::New( actor,
759                                                          Dali::Actor::Property::POSITION,
760                                                          Property::INVALID_COMPONENT_INDEX,
761                                                          new PathPositionFunctor( pathCopy ),
762                                                          alpha,
763                                                          period ) );
764
765   //If forward is zero, PathRotationFunctor will always return the unit quaternion
766   if( forward != Vector3::ZERO )
767   {
768     //Rotation animation
769     AddAnimatorConnector( AnimatorConnector<Quaternion>::New( actor,
770                                                               Dali::Actor::Property::ORIENTATION,
771                                                               Property::INVALID_COMPONENT_INDEX,
772                                                               new PathRotationFunctor( pathCopy, forward ),
773                                                               alpha,
774                                                               period ) );
775   }
776 }
777
778 void Animation::Show(Actor& actor, float delaySeconds)
779 {
780   ExtendDuration( TimePeriod(delaySeconds, 0) );
781
782   AddAnimatorConnector( AnimatorConnector<bool>::New( actor,
783                                                       Dali::Actor::Property::VISIBLE,
784                                                       Property::INVALID_COMPONENT_INDEX,
785                                                       new AnimateToBoolean(SHOW_VALUE),
786                                                       AlphaFunctions::Default,
787                                                       TimePeriod(delaySeconds, 0.0f/*immediate*/) ) );
788 }
789
790 void Animation::Hide(Actor& actor, float delaySeconds)
791 {
792   ExtendDuration( TimePeriod(delaySeconds, 0) );
793
794   AddAnimatorConnector( AnimatorConnector<bool>::New( actor,
795                                                       Dali::Actor::Property::VISIBLE,
796                                                       Property::INVALID_COMPONENT_INDEX,
797                                                       new AnimateToBoolean(HIDE_VALUE),
798                                                       AlphaFunctions::Default,
799                                                       TimePeriod(delaySeconds, 0.0f/*immediate*/) ) );
800 }
801
802 bool Animation::DoAction( BaseObject* object, const std::string& actionName, const std::vector<Property::Value>& attributes )
803 {
804   bool done = false;
805   Animation* animation = dynamic_cast<Animation*>( object );
806
807   if( animation )
808   {
809     if( 0 == strcmp( actionName.c_str(), ACTION_PLAY ) )
810     {
811       if( attributes.size() > 0 )
812       {
813         animation->SetDuration( attributes[0].Get<float>() );
814       }
815
816       animation->Play();
817       done = true;
818     }
819     else if( 0 == strcmp( actionName.c_str(), ACTION_STOP ) )
820     {
821       animation->Stop();
822       done = true;
823     }
824     else if( 0 == strcmp( actionName.c_str(), ACTION_PAUSE ) )
825     {
826       animation->Pause();
827       done = true;
828     }
829   }
830
831   return done;
832 }
833
834 void Animation::SetCurrentProgress(float progress)
835 {
836   if( mAnimation && progress >= mPlayRange.x && progress <= mPlayRange.y )
837   {
838     // mAnimation is being used in a separate thread; queue a message to set the current progress
839     SetCurrentProgressMessage( mEventThreadServices, *mAnimation, progress );
840   }
841 }
842
843 float Animation::GetCurrentProgress()
844 {
845   if( mAnimation )
846   {
847     return mAnimation->GetCurrentProgress();
848   }
849
850   return 0.0f;
851 }
852
853 void Animation::ExtendDuration( const TimePeriod& timePeriod )
854 {
855   float duration = timePeriod.delaySeconds + timePeriod.durationSeconds;
856
857   if( duration > mDurationSeconds )
858   {
859     SetDuration( duration );
860   }
861 }
862
863 void Animation::SetSpeedFactor( float factor )
864 {
865   if( mAnimation )
866   {
867     mSpeedFactor = factor;
868     SetSpeedFactorMessage( mEventThreadServices, *mAnimation, factor );
869   }
870 }
871
872 float Animation::GetSpeedFactor() const
873 {
874   return mSpeedFactor;
875 }
876
877 void Animation::SetPlayRange( const Vector2& range)
878 {
879   //Make sure the range specified is between 0.0 and 1.0
880   if( range.x >= 0.0f && range.x <= 1.0f && range.y >= 0.0f && range.y <= 1.0f )
881   {
882     Vector2 orderedRange( range );
883     //If the range is not in order swap values
884     if( range.x > range.y )
885     {
886       orderedRange = Vector2(range.y, range.x);
887     }
888
889     // Cache for public getters
890     mPlayRange = orderedRange;
891
892     // mAnimation is being used in a separate thread; queue a message to set play range
893     SetPlayRangeMessage( mEventThreadServices, *mAnimation, orderedRange );
894   }
895 }
896
897 Vector2 Animation::GetPlayRange() const
898 {
899   return mPlayRange;
900 }
901
902
903 } // namespace Internal
904
905 } // namespace Dali