Revert "License conversion from Flora to Apache 2.0"
[platform/core/uifw/dali-core.git] / dali / internal / event / animation / animator-connector.h
1 #ifndef __DALI_INTERNAL_ANIMATOR_CONNECTOR_H__
2 #define __DALI_INTERNAL_ANIMATOR_CONNECTOR_H__
3
4 //
5 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
6 //
7 // Licensed under the Flora License, Version 1.0 (the License);
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 //     http://floralicense.org/license/
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an AS IS BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19
20 // EXTERNAL INCLUDES
21 #include <boost/function.hpp>
22
23 // INTERNAL INCLUDES
24 #include <dali/internal/event/common/proxy-object.h>
25 #include <dali/internal/event/animation/animator-connector-base.h>
26 #include <dali/internal/event/animation/animation-impl.h>
27 #include <dali/internal/update/common/property-owner.h>
28 #include <dali/internal/update/animation/property-accessor.h>
29 #include <dali/internal/update/animation/property-component-accessor.h>
30 #include <dali/internal/update/animation/scene-graph-animator.h>
31 #include <dali/internal/update/manager/update-manager.h>
32
33 namespace Dali
34 {
35
36 namespace Internal
37 {
38
39 /**
40  * AnimatorConnector is used to connect SceneGraph::Animators for newly created scene-graph objects.
41  *
42  * The scene-graph objects are created by a ProxyObject e.g. Actor is a proxy for SceneGraph::Node.
43  * AnimatorConnector observes the proxy object, in order to detect when a scene-graph object is created.
44  *
45  * SceneGraph::Animators weakly reference scene objects, and are automatically deleted when orphaned.
46  * Therefore the AnimatorConnector is NOT responsible for disconnecting animators.
47  */
48 template < typename PropertyType >
49 class AnimatorConnector : public AnimatorConnectorBase, public ProxyObject::Observer
50 {
51 public:
52
53   typedef boost::function< PropertyType (float, const PropertyType&) > AnimatorFunction;
54   typedef SceneGraph::Animator< PropertyType, PropertyAccessor<PropertyType> > AnimatorType;
55   typedef SceneGraph::AnimatableProperty< PropertyType > PropertyInterfaceType;
56
57   /**
58    * Construct a new animator connector.
59    * @param[in] proxy The proxy for a scene-graph object to animate.
60    * @param[in] propertyIndex The index of a property provided by the object.
61    * @param[in] componentIndex Index to a sub component of a property, for use with Vector2, Vector3 and Vector4 (INVALID_PROPERTY_COMPONENTINDEX to use the whole property)
62    * @param[in] animatorFunction A function used to animate the property.
63    * @param[in] alpha The alpha function to apply.
64    * @param[in] period The time period of the animator.
65    * @return A pointer to a newly allocated animator connector.
66    */
67   static AnimatorConnectorBase* New( ProxyObject& proxy,
68                                      Property::Index propertyIndex,
69                                      int componentIndex,
70                                      const AnimatorFunction& animatorFunction,
71                                      AlphaFunction alpha,
72                                      const TimePeriod& period )
73   {
74     return new AnimatorConnector< PropertyType >( proxy,
75                                                   propertyIndex,
76                                                   componentIndex,
77                                                   animatorFunction,
78                                                   alpha,
79                                                   period );
80   }
81
82   /**
83    * Virtual destructor.
84    */
85   virtual ~AnimatorConnector()
86   {
87     if( mProxy )
88     {
89       mProxy->RemoveObserver( *this );
90     }
91
92     // Removing animators via Animation is not necessary.
93     // The corresponding scene graph animation will destroy any animators that become disconnected.
94   }
95
96   /**
97    * From AnimatorConnectorBase.
98    * This is only expected to be called once, when added to an Animation.
99    */
100   void SetParent( Animation& parent )
101   {
102     DALI_ASSERT_ALWAYS( mParent == NULL && "AnimationConnector already has a parent" );
103     mParent = &parent;
104
105     if( mProxy )
106     {
107       // Connect an animator, if the proxy has added an object to the scene-graph
108       const SceneGraph::PropertyOwner* object = mProxy->GetSceneObject();
109       if( object )
110       {
111         ConnectAnimator( *object );
112       }
113     }
114   }
115
116 private:
117
118   /**
119    * Private constructor; see also AnimatorConnector::New().
120    */
121   AnimatorConnector( ProxyObject& proxy,
122                      Property::Index propertyIndex,
123                      int componentIndex,
124                      const AnimatorFunction& animatorFunction,
125                      AlphaFunction alpha,
126                      const TimePeriod& period )
127   : AnimatorConnectorBase( alpha, period ),
128     mProxy( &proxy ),
129     mPropertyIndex( propertyIndex ),
130     mComponentIndex( componentIndex ),
131     mAnimatorFunction( animatorFunction ),
132     mConnected( false )
133   {
134     proxy.AddObserver( *this );
135   }
136
137   // Undefined
138   AnimatorConnector( const AnimatorConnector& );
139
140   // Undefined
141   AnimatorConnector& operator=( const AnimatorConnector& rhs );
142
143   /**
144    * From ProxyObject::Observer
145    */
146   virtual void SceneObjectAdded( ProxyObject& proxy )
147   {
148     const SceneGraph::PropertyOwner* object = mProxy->GetSceneObject();
149     DALI_ASSERT_DEBUG( NULL != object );
150
151     ConnectAnimator( *object );
152   }
153
154   /**
155    * From ProxyObject::Observer
156    */
157   virtual void SceneObjectRemoved( ProxyObject& proxy )
158   {
159     // Removing animators via Animation is not necessary.
160     // The corresponding scene graph animation will destroy any animators that become disconnected.
161     mConnected = false;
162   }
163
164   /**
165    * From ProxyObject::Observer
166    */
167   virtual void ProxyDestroyed( ProxyObject& proxy )
168   {
169     mConnected = false;
170     mProxy = NULL;
171   }
172
173   /**
174    * Create and connect an animator via update manager
175    */
176   void ConnectAnimator( const SceneGraph::PropertyOwner& object )
177   {
178     DALI_ASSERT_DEBUG( false == mConnected ); // Guard against double connections
179     DALI_ASSERT_DEBUG( NULL != mParent );
180
181     const SceneGraph::PropertyBase* base = mProxy->GetSceneObjectAnimatableProperty( mPropertyIndex );
182
183     const PropertyInterfaceType* sceneProperty = dynamic_cast< const PropertyInterfaceType* >( base );
184     DALI_ASSERT_DEBUG( NULL != sceneProperty && "Animating property with invalid type" );
185
186     SceneGraph::AnimatorBase* animator = AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
187     DALI_ASSERT_DEBUG( NULL != animator );
188
189     const SceneGraph::Animation* animation = mParent->GetSceneObject();
190     DALI_ASSERT_DEBUG( NULL != animation );
191
192     AddAnimatorMessage( mParent->GetUpdateManager().GetEventToUpdate(), *animation, *animator, object );
193
194     mConnected = true; // not really necessary, but useful for asserts
195   }
196
197 protected:
198
199   ProxyObject* mProxy; ///< Not owned by the animator connector. Valid until ProxyDestroyed() is called.
200
201   Property::Index mPropertyIndex;
202
203   int mComponentIndex;
204
205   AnimatorFunction mAnimatorFunction;
206
207   bool mConnected; ///< Used to guard against double connections
208 };
209
210 /**
211  * Variant which allows float components to be animated individually.
212  */
213 template <>
214 class AnimatorConnector<float> : public AnimatorConnectorBase, public ProxyObject::Observer
215 {
216 public:
217
218   typedef boost::function< float (float, const float&) > AnimatorFunction;
219   typedef SceneGraph::Animator< float, PropertyAccessor<float> > AnimatorType;
220
221   /**
222    * Construct a new animator connector.
223    * @param[in] proxy The proxy for a scene-graph object to animate.
224    * @param[in] propertyIndex The index of a property provided by the object.
225    * @param[in] componentIndex Index to a sub component of a property, for use with Vector2, Vector3 and Vector4
226    * @param[in] animatorFunction A function used to animate the property.
227    * @param[in] alpha The alpha function to apply.
228    * @param[in] period The time period of the animator.
229    * @return A pointer to a newly allocated animator connector.
230    */
231   static AnimatorConnectorBase* New( ProxyObject& proxy,
232                                      Property::Index propertyIndex,
233                                      int componentIndex,
234                                      const AnimatorFunction& animatorFunction,
235                                      AlphaFunction alpha,
236                                      const TimePeriod& period )
237   {
238     return new AnimatorConnector<float>( proxy,
239                                          propertyIndex,
240                                          componentIndex,
241                                          animatorFunction,
242                                          alpha,
243                                          period );
244   }
245
246   /**
247    * Virtual destructor.
248    */
249   virtual ~AnimatorConnector()
250   {
251     if( mProxy )
252     {
253       mProxy->RemoveObserver( *this );
254     }
255
256     // Removing animators via Animation is not necessary.
257     // The corresponding scene graph animation will destroy any animators that become disconnected.
258   }
259
260   /**
261    * From AnimatorConnectorBase.
262    * This is only expected to be called once, when added to an Animation.
263    */
264   void SetParent( Animation& parent )
265   {
266     DALI_ASSERT_ALWAYS( mParent == NULL && "AnimationConnector already has a parent");
267     mParent = &parent;
268
269     if( mProxy )
270     {
271       // Connect an animator, if the proxy has added an object to the scene-graph
272       const SceneGraph::PropertyOwner* object = mProxy->GetSceneObject();
273       if( object )
274       {
275         ConnectAnimator( *object );
276       }
277     }
278   }
279
280 private:
281
282   /**
283    * Private constructor; see also AnimatorConnector::New().
284    */
285   AnimatorConnector( ProxyObject& proxy,
286                      Property::Index propertyIndex,
287                      int componentIndex,
288                      const AnimatorFunction& animatorFunction,
289                      AlphaFunction alpha,
290                      const TimePeriod& period )
291   : AnimatorConnectorBase( alpha, period ),
292     mProxy( &proxy ),
293     mPropertyIndex( propertyIndex ),
294     mComponentIndex( componentIndex ),
295     mAnimatorFunction( animatorFunction ),
296     mConnected( false )
297   {
298     proxy.AddObserver( *this );
299   }
300
301   // Undefined
302   AnimatorConnector( const AnimatorConnector& );
303
304   // Undefined
305   AnimatorConnector& operator=( const AnimatorConnector& rhs );
306
307   /**
308    * From ProxyObject::Observer
309    */
310   virtual void SceneObjectAdded( ProxyObject& proxy )
311   {
312     const SceneGraph::PropertyOwner* object = mProxy->GetSceneObject();
313     DALI_ASSERT_DEBUG( NULL != object );
314
315     ConnectAnimator( *object );
316   }
317
318   /**
319    * From ProxyObject::Observer
320    */
321   virtual void SceneObjectRemoved( ProxyObject& proxy )
322   {
323     // Removing animators via Animation is not necessary.
324     // The corresponding scene graph animation will destroy any animators that become disconnected.
325     mConnected = false;
326   }
327
328   /**
329    * From ProxyObject::Observer
330    */
331   virtual void ProxyDestroyed( ProxyObject& proxy )
332   {
333     mConnected = false;
334     mProxy = NULL;
335   }
336
337   /**
338    * Create and connect an animator via update manager
339    */
340   void ConnectAnimator( const SceneGraph::PropertyOwner& object )
341   {
342     DALI_ASSERT_DEBUG( false == mConnected ); // Guard against double connections
343     DALI_ASSERT_DEBUG( NULL != mParent );
344
345     const SceneGraph::PropertyBase* base = mProxy->GetSceneObjectAnimatableProperty( mPropertyIndex );
346     DALI_ASSERT_DEBUG( NULL != base );
347
348     SceneGraph::AnimatorBase* animator( NULL );
349
350     const int componentIndex = mProxy->GetPropertyComponentIndex( mPropertyIndex );
351     if( componentIndex != Property::INVALID_COMPONENT_INDEX )
352     {
353       mComponentIndex = componentIndex;
354     }
355
356     if ( Property::INVALID_COMPONENT_INDEX == mComponentIndex )
357     {
358       // Not a Vector3 or Vector4 component, expecting float type
359       DALI_ASSERT_DEBUG( PropertyTypes::Get< float >() == base->GetType() );
360
361       typedef SceneGraph::AnimatableProperty< float > PropertyInterfaceType;
362
363       const PropertyInterfaceType* sceneProperty = dynamic_cast< const PropertyInterfaceType* >( base );
364       DALI_ASSERT_DEBUG( NULL != sceneProperty );
365
366       animator = AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
367     }
368     else
369     {
370       // Expecting Vector3 or Vector4 type
371
372       if ( PropertyTypes::Get< Vector3 >() == base->GetType() )
373       {
374         // Animate float component of Vector3 property
375         typedef SceneGraph::AnimatableProperty< Vector3 > PropertyInterfaceType;
376
377         const PropertyInterfaceType* sceneProperty = dynamic_cast< const PropertyInterfaceType* >( base );
378         DALI_ASSERT_DEBUG( NULL != sceneProperty );
379
380         if ( 0 == mComponentIndex )
381         {
382           typedef SceneGraph::Animator< float, PropertyComponentAccessorX<Vector3> > Vector3AnimatorType;
383           animator = Vector3AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
384         }
385         else if ( 1 == mComponentIndex )
386         {
387           typedef SceneGraph::Animator< float, PropertyComponentAccessorY<Vector3> > Vector3AnimatorType;
388           animator = Vector3AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
389         }
390         else if ( 2 == mComponentIndex )
391         {
392           typedef SceneGraph::Animator< float, PropertyComponentAccessorZ<Vector3> > Vector3AnimatorType;
393           animator = Vector3AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
394         }
395       }
396       else if ( PropertyTypes::Get< Vector4 >() == base->GetType() )
397       {
398         // Animate float component of Vector4 property
399         typedef SceneGraph::AnimatableProperty< Vector4 > PropertyInterfaceType;
400
401         const PropertyInterfaceType* sceneProperty = dynamic_cast< const PropertyInterfaceType* >( base );
402         DALI_ASSERT_DEBUG( NULL != sceneProperty );
403
404         if ( 0 == mComponentIndex )
405         {
406           typedef SceneGraph::Animator< float, PropertyComponentAccessorX<Vector4> > Vector4AnimatorType;
407           animator = Vector4AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
408         }
409         else if ( 1 == mComponentIndex )
410         {
411           typedef SceneGraph::Animator< float, PropertyComponentAccessorY<Vector4> > Vector4AnimatorType;
412           animator = Vector4AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
413         }
414         else if ( 2 == mComponentIndex )
415         {
416           typedef SceneGraph::Animator< float, PropertyComponentAccessorZ<Vector4> > Vector4AnimatorType;
417           animator = Vector4AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
418         }
419         else if ( 3 == mComponentIndex )
420         {
421           typedef SceneGraph::Animator< float, PropertyComponentAccessorW<Vector4> > Vector4AnimatorType;
422           animator = Vector4AnimatorType::New( *sceneProperty, mAnimatorFunction, mAlphaFunction, mTimePeriod );
423         }
424       }
425     }
426
427     DALI_ASSERT_DEBUG( NULL != animator && "Animating property with invalid type" );
428
429     const SceneGraph::Animation* animation = mParent->GetSceneObject();
430     DALI_ASSERT_DEBUG( NULL != animation );
431
432     AddAnimatorMessage( mParent->GetUpdateManager().GetEventToUpdate(), *animation, *animator, object );
433
434     mConnected = true; // not really necessary, but useful for asserts
435   }
436
437 protected:
438
439   ProxyObject* mProxy; ///< Not owned by the animator connector. Valid until ProxyDestroyed() is called.
440
441   Property::Index mPropertyIndex;
442
443   int mComponentIndex;
444
445   AnimatorFunction mAnimatorFunction;
446
447   bool mConnected; ///< Used to guard against double connections
448 };
449
450 } // namespace Internal
451
452 } // namespace Dali
453
454 #endif // __DALI_INTERNAL_ANIMATOR_CONNECTOR_H__