(Properties) Ensure TypeInfo is set when creating Type via TypeInfo
[platform/core/uifw/dali-core.git] / dali / internal / event / common / proxy-object.h
1 #ifndef __DALI_INTERNAL_PROXY_OBJECT_H__
2 #define __DALI_INTERNAL_PROXY_OBJECT_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 <string>
22
23 // INTERNAL INCLUDES
24 #include <dali/public-api/common/dali-vector.h>
25 #include <dali/public-api/common/vector-wrapper.h>
26 #include <dali/public-api/animation/active-constraint.h>
27 #include <dali/public-api/animation/animation.h>
28 #include <dali/public-api/animation/constraint.h>
29 #include <dali/public-api/object/constrainable.h>
30 #include <dali/public-api/object/property-input.h>
31 #include <dali/public-api/object/property-notification.h>
32 #include <dali/internal/event/common/object-impl.h>
33 #include <dali/internal/event/common/custom-property.h>
34 #include <dali/internal/event/common/property-input-impl.h>
35 #include <dali/internal/update/common/property-base.h>
36
37 namespace Dali
38 {
39
40 namespace Internal
41 {
42
43 class Stage;
44 class PropertyInputImpl;
45 class ProxyObject;
46 class Constraint;
47 class TypeInfo;
48
49 namespace SceneGraph
50 {
51 class PropertyBase;
52 class PropertyOwner;
53 }
54
55 typedef std::vector< Dali::ActiveConstraint >     ActiveConstraintContainer;
56 typedef ActiveConstraintContainer::iterator       ActiveConstraintIter;
57 typedef ActiveConstraintContainer::const_iterator ActiveConstraintConstIter;
58
59 /**
60  * A proxy for a property-owning object in the scene-graph.
61  * This provides an interface for observing the addition/removal of scene-objects.
62  *
63  * The concrete derived class is responsible for:
64  *   1) Adding & removing an object from the scene-graph. The OnSceneObjectAdd() and OnSceneObjectRemove()
65  *      methods should be called by the derived class, to trigger observer callbacks.
66  *   3) Implementing the GetSceneObject() methods, used to access the scene-object.
67  *   4) Providing access to properties stored by the scene-graph object. These should match the properties
68  *      reported by the base Dali::Internal::Object methods.
69  */
70 class ProxyObject : public Object
71 {
72 public:
73
74   class Observer
75   {
76   public:
77
78     /**
79      * Called immediately after the proxy has created & passed ownership of a scene-graph object.
80      * @param[in] proxy The proxy object.
81      */
82     virtual void SceneObjectAdded(ProxyObject& proxy) = 0;
83
84     /**
85      * Called shortly before the proxy sends a message to remove its scene object.
86      * @param[in] proxy The proxy object.
87      */
88     virtual void SceneObjectRemoved(ProxyObject& proxy) = 0;
89
90     /**
91      * Called shortly before the proxy itself is destroyed; no further callbacks will be received.
92      * @param[in] proxy The proxy object.
93      */
94     virtual void ProxyDestroyed(ProxyObject& proxy) = 0;
95
96   protected:
97     /**
98      * Virtual destructor
99      */
100     virtual ~Observer(){}
101   };
102
103   /**
104    * Constructor.
105    */
106   ProxyObject();
107
108   /**
109    * Query whether the proxy object removes (& re-adds) its associated scene-object.
110    * Otherwise the scene-object lifetime is expected to match that of the proxy.
111    * @return True if scene-objects are removed.
112    */
113   virtual bool IsSceneObjectRemovable() const = 0;
114
115   /**
116    * Add an observer to the proxy.
117    * @param[in] observer The observer to add.
118    */
119   virtual void AddObserver(Observer& observer);
120
121   /**
122    * Remove an observer from the proxy
123    * @pre The observer has already been added.
124    * @param[in] observer The observer to remove.
125    */
126   virtual void RemoveObserver(Observer& observer);
127
128   /**
129    * Retrieve the scene-graph object added by this proxy.
130    * @return A pointer to the object, or NULL if no object has been added to the scene-graph.
131    */
132   virtual const SceneGraph::PropertyOwner* GetSceneObject() const = 0;
133
134   /**
135    * Retrieve an animatable property owned by the scene-graph object.
136    * @pre -1 < index < GetPropertyCount().
137    * @param[in] index The index of the property.
138    * @return A dereferenceable pointer to a property, or NULL if a scene-object does not exist with this property.
139    */
140   virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const = 0;
141
142   /**
143    * Retrieve an constraint input-property owned by the scene-graph object.
144    * @pre -1 < index < GetPropertyCount().
145    * @param[in] index The index of the property.
146    * @return A dereferenceable pointer to an input property, or NULL if a scene-object does not exist with this property.
147    */
148   virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const = 0;
149
150   /**
151    * Query whether the property is a component of a scene-graph property.
152    * @pre -1 < index < GetPropertyCount().
153    * @param[in] index The index of the property.
154    * @return The index or Property::INVALID_COMPONENT_INDEX.
155    */
156   virtual int GetPropertyComponentIndex( Property::Index index ) const;
157
158 public: // Property system interface from Internal::Object
159
160   /**
161    * @copydoc Dali::Internal::Object::Supports()
162    */
163   virtual bool Supports( Object::Capability capability ) const;
164
165   /**
166    * @copydoc Dali::Internal::Object::GetPropertyCount()
167    */
168   virtual unsigned int GetPropertyCount() const;
169
170   /**
171    * @copydoc Dali::Internal::Object::GetPropertyName()
172    */
173   virtual const std::string& GetPropertyName( Property::Index index ) const;
174
175   /**
176    * @copydoc Dali::Internal::Object::GetPropertyIndex()
177    */
178   virtual Property::Index GetPropertyIndex(const std::string& name) const;
179
180   /**
181    * @copydoc Dali::Internal::Object::IsPropertyWritable()
182    */
183   virtual bool IsPropertyWritable(Property::Index index) const;
184
185   /**
186    * @copydoc Dali::Internal::Object::IsPropertyAnimatable()
187    */
188   virtual bool IsPropertyAnimatable(Property::Index index) const;
189
190   /**
191    * @copydoc Dali::Internal::Object::IsPropertyAConstraintInput()
192    */
193   virtual bool IsPropertyAConstraintInput(Property::Index index) const;
194
195   /**
196    * @copydoc Dali::Internal::Object::GetPropertyType()
197    */
198   virtual Property::Type GetPropertyType(Property::Index index) const;
199
200   /**
201    * @copydoc Dali::Internal::Object::SetProperty()
202    */
203   virtual void SetProperty(Property::Index index, const Property::Value& propertyValue);
204
205   /**
206    * @copydoc Dali::Internal::Object::GetProperty()
207    */
208   virtual Property::Value GetProperty(Property::Index index) const;
209
210   /**
211    * @copydoc Dali::Handle::GetPropertyIndices()
212    */
213   virtual void GetPropertyIndices( Property::IndexContainer& indices ) const;
214
215   /**
216    * @copydoc Dali::Internal::Object::RegisterProperty()
217    */
218   virtual Property::Index RegisterProperty(std::string name, const Property::Value& propertyValue);
219
220   /**
221    * @copydoc Dali::Handle::RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode)
222    */
223   virtual Property::Index RegisterProperty(std::string name, const Property::Value& propertyValue, Property::AccessMode accessMode);
224
225   /**
226    * @copydoc Dali::Handle::AddPropertyNotification()
227    */
228   virtual Dali::PropertyNotification AddPropertyNotification(Property::Index index,
229                                                              int componentIndex,
230                                                              const Dali::PropertyCondition& condition);
231
232   /**
233    * @copydoc Dali::Handle::RemovePropertyNotification()
234    */
235   virtual void RemovePropertyNotification(Dali::PropertyNotification propertyNotification);
236
237   /**
238    * @copydoc Dali::Handle::RemovePropertyNotifications()
239    */
240   void RemovePropertyNotifications();
241
242 private:
243   /**
244    * Enable property notifications in scene graph
245    */
246   void EnablePropertyNotifications();
247
248   /**
249    * Enable property notifications in scene graph
250    */
251   void DisablePropertyNotifications();
252
253 public: // Constraints
254
255   /**
256    * Apply a constraint to a ProxyObject.
257    * @param[in] constraint The constraint to apply.
258    */
259   Dali::ActiveConstraint ApplyConstraint( Constraint& constraint );
260
261   /**
262    * Apply a constraint to a ProxyObject.
263    * @param[in] constraint The constraint to apply.
264    * @param[in] weightObject An object with a "weight" float property.
265    */
266   Dali::ActiveConstraint ApplyConstraint( Constraint& constraint, Dali::Constrainable weightObject );
267
268   /**
269    * Remove one constraint from a ProxyObject.
270    * @param[in] activeConstraint The active constraint to remove.
271    */
272   void RemoveConstraint( Dali::ActiveConstraint activeConstraint );
273
274   /**
275    * Remove all constraints from a ProxyObject.
276    */
277   void RemoveConstraints();
278
279   /**
280    * Remove all constraints from a ProxyObject with a matching tag
281    */
282   void RemoveConstraints( unsigned int tag );
283
284 public: // Called by TypeInfo
285
286   /**
287    * Called by TypeInfo to set the type-info that this proxy-object is created by.
288    * @param[in] typeInfo The TypeInfo that creates this proxy-object.
289    */
290   void SetTypeInfo( TypeInfo* typeInfo );
291
292 protected:
293
294   /**
295    * Called immediately by derived classes, after the scene-object has been created & passed to the scene-graph.
296    */
297   void OnSceneObjectAdd();
298
299   /**
300    * Called by derived classes, shortly before send a message to remove the scene-object.
301    */
302   void OnSceneObjectRemove();
303
304   /**
305    * A reference counted object may only be deleted by calling Unreference()
306    */
307   virtual ~ProxyObject();
308
309 private:
310
311   // Undefined
312   ProxyObject(const ProxyObject&);
313
314   // Undefined
315   ProxyObject& operator=(const ProxyObject& rhs);
316
317   /**
318    * Helper for ApplyConstraint overloads.
319    * @param[in] constraint The constraint to apply.
320    * @param[in] weightObject An object with a "weight" float property, or an empty handle.
321    * @return The new active-constraint which is owned by ProxyObject.
322    */
323   ActiveConstraintBase* DoApplyConstraint( Constraint& constraint, Dali::Constrainable weightObject );
324
325   /**
326    * Helper to delete removed constraints
327    */
328   void DeleteRemovedConstraints();
329
330   /**
331    * Helper to remove active constraints
332    */
333   void RemoveConstraint( ActiveConstraint& constraint, bool isInScenegraph );
334
335
336 private: // Default property extensions for derived classes
337
338   /**
339    * Query how many default properties the derived class supports.
340    * @return The number of default properties.
341    */
342   virtual unsigned int GetDefaultPropertyCount() const = 0;
343
344   /**
345    * Retrieve all the indices that are associated with the default properties supported by the derived class.
346    * @return A container of default property indices.
347    * @note The deriving class must not modify the existing elements in the container.
348    */
349   virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const = 0;
350
351   /**
352    * Query how many default properties the derived class supports.
353    * @return The number of default properties.
354    */
355   virtual const std::string& GetDefaultPropertyName( Property::Index index ) const = 0;
356
357   /**
358    * Query the index of a default property.
359    * @param [in] name The name of the property.
360    * @return The index of the property, or Property::INVALID_INDEX if no default property exists with the given name.
361    */
362   virtual Property::Index GetDefaultPropertyIndex( const std::string& name ) const = 0;
363
364   /**
365    * Query whether a default property is writable.
366    * @param [in] index The index of the property.
367    * @return True if the property is animatable.
368    */
369   virtual bool IsDefaultPropertyWritable( Property::Index index ) const = 0;
370
371   /**
372    * Query whether a default property is animatable.
373    * This determines whether the property can be the target of an animation or constraint.
374    * @param [in] index The index of the property.
375    * @return True if the property is animatable.
376    */
377   virtual bool IsDefaultPropertyAnimatable( Property::Index index ) const = 0;
378
379   /**
380    * @brief Query whether a default property can be used as an input to a constraint.
381    *
382    * @param [in] index The index of the property.
383    * @return True if the property can be used as an input to a constraint.
384    */
385   virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const = 0;
386
387   /**
388    * Query the type of a default property.
389    * @param [in] index The index of the property.
390    * @return The type of the property.
391    */
392   virtual Property::Type GetDefaultPropertyType( Property::Index index ) const = 0;
393
394   /**
395    * Set the value of a default property.
396    * @pre The property types match i.e. propertyValue.GetType() is equal to GetPropertyType(index).
397    * @param [in] index The index of the property.
398    * @param [in] propertyValue The new value of the property.
399    */
400   virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) = 0;
401
402   /**
403    * Set the value of custom property.
404    * @param [in] index The index of the property.
405    * @param [in] entry An entry from the CustomPropertyLookup.
406    * @param [in] value The new value of the property.
407    */
408   virtual void SetCustomProperty( Property::Index index, const CustomProperty& entry, const Property::Value& value );
409
410   /**
411    * Retrieve a default property value.
412    * @param [in] index The index of the property.
413    * @return The property value.
414    */
415   virtual Property::Value GetDefaultProperty( Property::Index index ) const = 0;
416
417   /**
418    * Install a newly allocated scene-object property.
419    * The derived class is responsible for this, since the type of scene-object is not known to this base class.
420    * @param [in] newProperty A newly allocated scene-object property.
421    * @param [in] name The name allocated to this custom property.
422    * @param [in] index The index allocated to this custom property.
423    */
424   virtual void InstallSceneObjectProperty( SceneGraph::PropertyBase& newProperty, const std::string& name, unsigned int index ) = 0;
425
426 protected:
427
428   /**
429    * Not all proxy objects will have custom properties so we want to only create the lookup when its actually needed
430    * @return the custom property lookup
431    */
432   CustomPropertyLookup& GetCustomPropertyLookup() const;
433
434   /**
435    * Retrieves the TypeInfo for this object. Only retrieves it from the type-registry once and then stores a pointer
436    * to it locally there-after. The type info will not change during the life-time of the application.
437    * @return The type-info for this object (Can be NULL)
438    */
439   TypeInfo* GetTypeInfo() const;
440
441 private:
442
443   Property::Index mNextCustomPropertyIndex; ///< The ID of the next custom property to be registered
444
445   mutable CustomPropertyLookup* mCustomProperties; ///< Used for accessing custom Node properties, mutable so it can be lazy initialized from const function
446   mutable TypeInfo* mTypeInfo; ///< The type-info for this object, mutable so it can be lazy initialized from const method if it is required
447
448   Dali::Vector<Observer*> mObservers;
449
450   ActiveConstraintContainer* mConstraints;               ///< Container of owned active-constraints.
451   ActiveConstraintContainer* mRemovedConstraints;        ///< Container of owned active-constraints, which are being removed.
452
453   typedef std::vector< Dali::PropertyNotification >     PropertyNotificationContainer;
454   typedef PropertyNotificationContainer::iterator       PropertyNotificationContainerIter;
455   typedef PropertyNotificationContainer::const_iterator PropertyNotificationContainerConstIter;
456   PropertyNotificationContainer* mPropertyNotifications; ///< Container of owned property notifications.
457 };
458
459 } // namespace Internal
460
461 inline Internal::ProxyObject& GetImplementation(Dali::Constrainable& object)
462 {
463   DALI_ASSERT_ALWAYS( object && "ProxyObject handle is empty" );
464   BaseObject& handle = object.GetBaseObject();
465   return static_cast<Internal::ProxyObject&>(handle);
466 }
467
468 inline const Internal::ProxyObject& GetImplementation(const Dali::Constrainable& object)
469 {
470   DALI_ASSERT_ALWAYS( object && "ProxyObject handle is empty" );
471   const BaseObject& handle = object.GetBaseObject();
472   return static_cast<const Internal::ProxyObject&>(handle);
473 }
474
475
476 } // namespace Dali
477
478 #endif // __DALI_INTERNAL_PROXY_OBJECT_H__