Merge remote-tracking branch 'origin/tizen' into devel/new_mesh
[platform/core/uifw/dali-core.git] / dali / internal / event / common / object-impl.h
1 #ifndef __DALI_INTERNAL_OBJECT_H__
2 #define __DALI_INTERNAL_OBJECT_H__
3
4 /*
5  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  */
20
21 // INTERNAL INCLUDES
22 #include <dali/public-api/animation/constraint.h>
23 #include <dali/public-api/common/dali-vector.h>
24 #include <dali/public-api/common/vector-wrapper.h>
25 #include <dali/public-api/object/base-object.h>
26 #include <dali/public-api/object/handle.h>
27 #include <dali/public-api/object/property.h>
28 #include <dali/public-api/object/property-index-ranges.h>
29 #include <dali/public-api/object/property-input.h>
30 #include <dali/public-api/object/property-notification.h>
31 #include <dali/internal/common/owner-container.h>
32 #include <dali/internal/event/common/event-thread-services.h>
33 #include <dali/internal/event/common/property-input-impl.h>
34 #include <dali/internal/event/common/property-metadata.h>
35 #include <dali/internal/update/common/property-base.h>
36
37 namespace Dali
38 {
39
40 class PropertyNotification;
41
42 namespace Internal
43 {
44 class ConstraintBase;
45 class EventThreadServices;
46 class Handle;
47 class PropertyCondition;
48 class PropertyInputImpl;
49 class Stage;
50 class TypeInfo;
51
52 namespace SceneGraph
53 {
54 class PropertyBase;
55 class PropertyOwner;
56 }
57
58 typedef std::vector< Dali::Constraint >     ConstraintContainer;
59 typedef ConstraintContainer::iterator       ConstraintIter;
60 typedef ConstraintContainer::const_iterator ConstraintConstIter;
61
62
63 /**
64  * A base class for objects which optionally provide properties.
65  * The concrete derived class is responsible for implementing the property system methods.
66  * Classes may derive from Dali::BaseObject, until any properties are required.
67  *
68  * An object for a property-owning object in the scene-graph.
69  * This provides an interface for observing the addition/removal of scene-objects.
70  *
71  * The concrete derived class is responsible for:
72  *   1) Adding & removing an object from the scene-graph. The OnSceneObjectAdd() and OnSceneObjectRemove()
73  *      methods should be called by the derived class, to trigger observer callbacks.
74  *   3) Implementing the GetSceneObject() methods, used to access the scene-object.
75  *   4) Providing access to properties stored by the scene-graph object. These should match the properties
76  *      reported by the base Dali::Internal::Object methods.
77  *
78  */
79 class Object : public Dali::BaseObject
80 {
81 public:
82
83   typedef Dali::Handle::Capability Capability;
84
85   class Observer
86   {
87   public:
88
89     /**
90      * Called immediately after the object has created & passed ownership of a scene-graph object.
91      * @param[in] object The object object.
92      */
93     virtual void SceneObjectAdded(Object& object) = 0;
94
95     /**
96      * Called shortly before the object sends a message to remove its scene object.
97      * @param[in] object The object object.
98      */
99     virtual void SceneObjectRemoved(Object& object) = 0;
100
101     /**
102      * Called shortly before the object itself is destroyed; no further callbacks will be received.
103      * @param[in] object The object object.
104      */
105     virtual void ObjectDestroyed(Object& object) = 0;
106
107   protected:
108
109     /**
110      * Virtual destructor
111      */
112     virtual ~Observer(){}
113   };
114
115   /**
116    * Constructor.
117    */
118   Object();
119
120   /**
121    * Add an observer to the object.
122    * @param[in] observer The observer to add.
123    */
124   virtual void AddObserver( Observer& observer );
125
126   /**
127    * Remove an observer from the object
128    * @pre The observer has already been added.
129    * @param[in] observer The observer to remove.
130    */
131   virtual void RemoveObserver( Observer& observer );
132
133   /**
134    * @copydoc Dali::Handle::Supports()
135    */
136   virtual bool Supports( Capability capability ) const;
137
138   /**
139    * @copydoc Dali::Handle::GetPropertyCount()
140    */
141   virtual unsigned int GetPropertyCount() const;
142
143   /**
144    * @copydoc Dali::Handle::GetPropertyName()
145    */
146   virtual std::string GetPropertyName( Property::Index index ) const;
147
148   /**
149    * @copydoc Dali::Handle::GetPropertyIndex()
150    */
151   virtual Property::Index GetPropertyIndex( const std::string& name ) const;
152
153   /**
154    * @copydoc Dali::Handle::IsPropertyWritable()
155    */
156   virtual bool IsPropertyWritable( Property::Index index ) const;
157
158   /**
159    * @copydoc Dali::Handle::IsPropertyAnimatable()
160    */
161   virtual bool IsPropertyAnimatable( Property::Index index ) const;
162
163   /**
164    * @copydoc Dali::Handle::IsPropertyAConstraintInput()
165    */
166   virtual bool IsPropertyAConstraintInput( Property::Index index ) const;
167
168   /**
169    * @copydoc Dali::Handle::GetPropertyType()
170    */
171   virtual Property::Type GetPropertyType( Property::Index index ) const;
172
173   /**
174    * @copydoc Dali::Handle::SetProperty()
175    */
176   virtual void SetProperty( Property::Index index, const Property::Value& propertyValue );
177
178   /**
179    * @copydoc Dali::Handle::GetProperty()
180    */
181   virtual Property::Value GetProperty( Property::Index index ) const;
182
183   /**
184    * @copydoc Dali::Handle::GetPropertyIndices()
185    */
186   virtual void GetPropertyIndices( Property::IndexContainer& indices ) const;
187
188   /**
189    * @copydoc Dali::Handle::RegisterProperty()
190    */
191   virtual Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue );
192
193   /**
194    * @copydoc Dali::Handle::RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode)
195    */
196   virtual Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode );
197
198   /**
199    * @copydoc Dali::Handle::AddPropertyNotification()
200    */
201   virtual Dali::PropertyNotification AddPropertyNotification( Property::Index index,
202                                                               int componentIndex,
203                                                               const Dali::PropertyCondition& condition );
204
205   /**
206    * @copydoc Dali::Handle::RemovePropertyNotification()
207    */
208   virtual void RemovePropertyNotification( Dali::PropertyNotification propertyNotification );
209
210   /**
211    * @copydoc Dali::Handle::RemovePropertyNotifications()
212    */
213   virtual void RemovePropertyNotifications();
214
215   /******************************** Uniform Mappings ********************************/
216
217   /**
218    * @copydoc Dali::Handle::AddUniformMapping()
219    */
220   void AddUniformMapping( Property::Index propertyIndex, const std::string& uniformName );
221
222   /**
223    * @copydoc Dali::Handle::RemoveUniformMapping( )
224    */
225   void RemoveUniformMapping( const std::string& uniformName );
226
227   /******************************** Constraints ********************************/
228
229   /**
230    * Apply a constraint to an Object.
231    * @param[in] constraint The constraint to apply.
232    */
233   void ApplyConstraint( ConstraintBase& constraint );
234
235   /**
236    * Remove one constraint from an Object.
237    * @param[in] constraint The constraint to remove.
238    */
239   void RemoveConstraint( ConstraintBase& constraint );
240
241   /**
242    * Remove all constraints from a Object.
243    */
244   void RemoveConstraints();
245
246   /**
247    * Remove all constraints from a Object with a matching tag
248    */
249   void RemoveConstraints( unsigned int tag );
250
251   /**
252    * Called by TypeInfo to set the type-info that this object-impl is created by.
253    * @param[in] typeInfo The TypeInfo that creates this object-impl.
254    */
255   void SetTypeInfo( const TypeInfo* typeInfo );
256
257   /**
258    * @return the index from which custom properties start
259    */
260   unsigned int CustomPropertyStartIndex()
261   {
262     return PROPERTY_CUSTOM_START_INDEX;
263   }
264
265   /********************  To be overridden by deriving classes ********************/
266
267   /**
268    * Retrieve the scene-graph object added by this object.
269    * @return A pointer to the object, or NULL if no object has been added to the scene-graph.
270    */
271   virtual const SceneGraph::PropertyOwner* GetSceneObject() const = 0;
272
273   /**
274    * Retrieve an animatable property owned by the scene-graph object.
275    * @pre -1 < index < GetPropertyCount().
276    * @param[in] index The index of the property.
277    * @return A dereferenceable pointer to a property, or NULL if a scene-object does not exist with this property.
278    */
279   virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const = 0;
280
281   /**
282    * Retrieve a constraint input-property owned by the scene-graph object.
283    * @pre -1 < index < GetPropertyCount().
284    * @param[in] index The index of the property.
285    * @return A dereferenceable pointer to an input property, or NULL if a scene-object does not exist with this property.
286    */
287   virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const = 0;
288
289   /**
290    * Query whether the property is a component of a scene-graph property.
291    * @pre -1 < index < GetPropertyCount().
292    * @param[in] index The index of the property.
293    * @return The index or Property::INVALID_COMPONENT_INDEX.
294    */
295   virtual int GetPropertyComponentIndex( Property::Index index ) const;
296
297 protected:
298
299   /**
300    * A reference counted object may only be deleted by calling Unreference()
301    */
302   virtual ~Object();
303
304   /**
305    * Called immediately by derived classes, after the scene-object has been created & passed to the scene-graph.
306    */
307   void OnSceneObjectAdd();
308
309   /**
310    * Called by derived classes, shortly before send a message to remove the scene-object.
311    */
312   void OnSceneObjectRemove();
313
314   /**
315    * For use in derived classes.
316    * This is called after a property is set.
317    * @param [in] index The index of the property.
318    * @param [in] propertyValue The value of the property.
319    */
320   virtual void OnPropertySet( Property::Index index, Property::Value propertyValue ) {}
321
322   /**
323    * Retrieves the TypeInfo for this object. Only retrieves it from the type-registry once and then stores a pointer
324    * to it locally there-after. The type info will not change during the life-time of the application.
325    * @return The type-info for this object (Can be NULL)
326    */
327   const TypeInfo* GetTypeInfo() const;
328
329   /**
330    * Helper to find custom property
331    * @param index
332    * @return pointer to the property
333    */
334   CustomPropertyMetadata* FindCustomProperty( Property::Index index ) const;
335
336   /**
337    * Helper to find animatable property
338    * @param index
339    * @return pointer to the property
340    */
341   AnimatablePropertyMetadata* FindAnimatableProperty( Property::Index index ) const;
342
343   /**
344    * Helper to register a scene-graph property
345    * @param [in] name The name of the property.
346    * @param [in] index The index of the property
347    * @param [in] value The value of the property.
348    * @return The index of the registered property or Property::INVALID_INDEX if registration failed.
349    */
350   Property::Index RegisterSceneGraphProperty(const std::string& name, Property::Index index, const Property::Value& propertyValue) const;
351
352   /**
353    * Check whether the animatable property is registered already, if not then register one.
354    * @param [in] index The index of the property
355    * @return pointer to the property.
356    */
357   AnimatablePropertyMetadata* RegisterAnimatableProperty(Property::Index index) const;
358
359 private: // Default property extensions for derived classes
360
361   /**
362    * Query how many default properties the derived class supports.
363    * @return The number of default properties.
364    */
365   virtual unsigned int GetDefaultPropertyCount() const = 0;
366
367   /**
368    * Retrieve all the indices that are associated with the default properties supported by the derived class.
369    * @return A container of default property indices.
370    * @note The deriving class must not modify the existing elements in the container.
371    */
372   virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const = 0;
373
374   /**
375    * Query how many default properties the derived class supports.
376    * @return The number of default properties.
377    */
378   virtual const char* GetDefaultPropertyName( Property::Index index ) const = 0;
379
380   /**
381    * Query the index of a default property.
382    * @param [in] name The name of the property.
383    * @return The index of the property, or Property::INVALID_INDEX if no default property exists with the given name.
384    */
385   virtual Property::Index GetDefaultPropertyIndex( const std::string& name ) const = 0;
386
387   /**
388    * Query whether a default property is writable.
389    * @param [in] index The index of the property.
390    * @return True if the property is animatable.
391    */
392   virtual bool IsDefaultPropertyWritable( Property::Index index ) const = 0;
393
394   /**
395    * Query whether a default property is animatable.
396    * This determines whether the property can be the target of an animation or constraint.
397    * @param [in] index The index of the property.
398    * @return True if the property is animatable.
399    */
400   virtual bool IsDefaultPropertyAnimatable( Property::Index index ) const = 0;
401
402   /**
403    * @brief Query whether a default property can be used as an input to a constraint.
404    *
405    * @param [in] index The index of the property.
406    * @return True if the property can be used as an input to a constraint.
407    */
408   virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const = 0;
409
410   /**
411    * Query the type of a default property.
412    * @param [in] index The index of the property.
413    * @return The type of the property.
414    */
415   virtual Property::Type GetDefaultPropertyType( Property::Index index ) const = 0;
416
417   /**
418    * Set the value of a default property.
419    * @pre The property types match i.e. propertyValue.GetType() is equal to GetPropertyType(index).
420    * @param [in] index The index of the property.
421    * @param [in] propertyValue The new value of the property.
422    */
423   virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) = 0;
424
425   /**
426    * Retrieve a default property value.
427    * @param [in] index The index of the property.
428    * @return The property value.
429    */
430   virtual Property::Value GetDefaultProperty( Property::Index index ) const = 0;
431
432   /**
433    * @todo this is virtual so that for now actor can override it,
434    * it needs to be removed and only have GetSceneObject but that requires changing actor and constraint logic
435    * Retrieve the scene-graph object added by this object.
436    * @return A pointer to the object, or NULL if no object has been added to the scene-graph.
437    */
438   virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const
439   {
440     return GetSceneObject();
441   }
442
443   /**
444    * Notify derived class of installation of a new scene-object property.
445    * This method is called after the message is to sent to install the property
446    * @param [in] newProperty A newly allocated scene-object property. Ownership is obviously not passed.
447    * @param [in] name The name allocated to this custom property.
448    * @param [in] index The index allocated to this custom property.
449    */
450   virtual void NotifyScenePropertyInstalled( const SceneGraph::PropertyBase& newProperty, const std::string& name, unsigned int index ) const
451   { }
452
453 private:
454
455   // Not implemented
456   Object(const Object& rhs);
457
458   // Not implemented
459   Object& operator=(const Object& rhs);
460
461   /**
462    * Enable property notifications in scene graph
463    */
464   void EnablePropertyNotifications();
465
466   /**
467    * Enable property notifications in scene graph
468    */
469   void DisablePropertyNotifications();
470
471   /**
472    * Get the value of the property.
473    * @param [in] entry An entry from the property lookup container.
474    * @return The new value of the property.
475    */
476   Property::Value GetPropertyValue( const PropertyMetadata* entry ) const;
477
478   /**
479    * Set the value of scene graph property.
480    * @param [in] index The index of the property.
481    * @param [in] entry An entry from the property lookup container.
482    * @param [in] value The new value of the property.
483    */
484   virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
485
486 protected:
487   /**
488    * Get the event thread services object - used for sending messages to the scene graph
489    * Assert if called from the wrong thread.
490    * This is intentionally inline for performance reasons.
491    *
492    * @return The event thread services object
493    */
494   inline EventThreadServices& GetEventThreadServices()
495   {
496     DALI_ASSERT_DEBUG( EventThreadServices::IsCoreRunning() );
497     return mEventThreadServices;
498   }
499
500   /**
501    * Get the event thread services object - used for sending messages to the scene graph
502    * Assert if called from the wrong thread
503    * This is intentionally inline for performance reasons.
504    *
505    * @return The event thread services object
506    */
507   inline const EventThreadServices& GetEventThreadServices() const
508   {
509     DALI_ASSERT_DEBUG( EventThreadServices::IsCoreRunning() );
510     return mEventThreadServices;
511   }
512
513 private:
514   EventThreadServices& mEventThreadServices;
515
516 private:
517
518   typedef OwnerContainer<PropertyMetadata*> PropertyMetadataLookup;
519   mutable PropertyMetadataLookup mCustomProperties; ///< Used for accessing custom Node properties
520   mutable PropertyMetadataLookup mAnimatableProperties; ///< Used for accessing animatable Node properties
521   mutable TypeInfo const *  mTypeInfo; ///< The type-info for this object, mutable so it can be lazy initialized from const method if it is required
522
523   Dali::Vector<Observer*> mObservers;
524
525   ConstraintContainer* mConstraints;               ///< Container of owned -constraints.
526
527   typedef std::vector< Dali::PropertyNotification >     PropertyNotificationContainer;
528   typedef PropertyNotificationContainer::iterator       PropertyNotificationContainerIter;
529   typedef PropertyNotificationContainer::const_iterator PropertyNotificationContainerConstIter;
530   PropertyNotificationContainer* mPropertyNotifications; ///< Container of owned property notifications.
531 };
532 } // namespace Internal
533
534 // Helpers for public-api forwarding methods
535
536 inline Internal::Object& GetImplementation(Dali::Handle& object)
537 {
538   DALI_ASSERT_ALWAYS( object && "Object handle is empty" );
539
540   BaseObject& handle = object.GetBaseObject();
541
542   return static_cast<Internal::Object&>(handle);
543 }
544
545 inline const Internal::Object& GetImplementation(const Dali::Handle& object)
546 {
547   DALI_ASSERT_ALWAYS( object && "Object handle is empty" );
548
549   const BaseObject& handle = object.GetBaseObject();
550
551   return static_cast<const Internal::Object&>(handle);
552 }
553
554 } // namespace Dali
555
556 #endif // __DALI_INTERNAL_OBJECT_H__