dali/internal/event/common/property-metadata.h

   1 #ifndef __DALI_INTERNAL_PROPERTY_METADATA_H__
   2 #define __DALI_INTERNAL_PROPERTY_METADATA_H__
   3
   4 /*
   5  * Copyright (c) 2014 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 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23 #include <utility>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/public-api/common/constants.h>
  27 #include <dali/public-api/object/property.h>
  28
  29 namespace Dali
  30 {
  31
  32 namespace Internal
  33 {
  34
  35 namespace SceneGraph
  36 {
  37 class PropertyBase;
  38 }
  39
  40 /**
  41  * An entry in a property metadata lookup.
  42  * The type field should be queried, before accessing the scene-graph property:
  43  *
  44  * @code
  45  * void Example(PropertyEntry entry)
  46  * {
  47  *   if (entry.type == Property::VECTOR3)
  48  *   {
  49  *     SceneGraph::AnimatableProperty<Vector3>* property = dynamic_cast< SceneGraph::AnimatableProperty<Vector3>* >( entry.property );
  50  *     ...
  51  *   }
  52  * @endcode
  53  *
  54  */
  55 class PropertyMetadata
  56 {
  57 public:
  58
  59   /**
  60    * Constructor for an uninitalized property metadata
  61    */
  62   PropertyMetadata()
  63   : type(Property::NONE),
  64     value(),
  65     mProperty(NULL)
  66   {
  67   }
  68
  69   /**
  70    * Constructor for property metadata
  71    * @param [in] newProperty A pointer to the property metadata.
  72    */
  73   PropertyMetadata(const SceneGraph::PropertyBase* newProperty)
  74   : type(Property::NONE),
  75     value(), // value is held by newProperty
  76     mProperty(newProperty)
  77   {
  78     DALI_ASSERT_DEBUG(mProperty && "Uninitialized scenegraph property") ;
  79   }
  80
  81   /**
  82    * Constructor for property metadata
  83    * @param [in] newValue The value of the scene-graph owned property.
  84    */
  85   PropertyMetadata(Property::Value newValue)
  86   : type(newValue.GetType()),
  87     value(newValue),
  88     mProperty(NULL)
  89   {
  90   }
  91
  92   /**
  93    * Destructor for property metadata
  94    */
  95   virtual ~PropertyMetadata()
  96   {
  97   }
  98
  99   /**
 100    * @return true if the property is animatable (i.e. if its a scene graph property)
 101    */
 102   bool IsAnimatable(void) const
 103   {
 104     return NULL != mProperty;
 105   }
 106
 107   /**
 108    * @return true if the property can be written to
 109    */
 110   virtual bool IsWritable(void) const = 0;
 111
 112   /**
 113    * @return the scene graph property
 114    */
 115   const SceneGraph::PropertyBase* GetSceneGraphProperty() const
 116   {
 117     DALI_ASSERT_DEBUG(mProperty && "Accessing uninitialized SceneGraph property") ;
 118     return mProperty;
 119   }
 120
 121   Property::Type type;    ///< The type of the property
 122   Property::Value value;  ///< The property value for a non animatable and custom property
 123
 124 protected:
 125
 126   // Not implemented
 127   PropertyMetadata( const PropertyMetadata& );
 128   PropertyMetadata& operator=( const PropertyMetadata& );
 129
 130   const SceneGraph::PropertyBase* mProperty; ///< A pointer to a scene-graph property; should not be modified from actor-thread.
 131 };
 132
 133
 134 /**
 135  * An entry in an animatable property metadata lookup.
 136  * The type field should be queried, before accessing the animatable property:
 137  */
 138 class AnimatablePropertyMetadata : public PropertyMetadata
 139 {
 140 public:
 141
 142   /**
 143    * Constructor for metadata of animatable property
 144    * @param [in] newProperty A pointer to the scene-graph owned property.
 145    */
 146   AnimatablePropertyMetadata( Property::Type newType,
 147                         const SceneGraph::PropertyBase* newProperty )
 148   {
 149     type = newType;
 150     mProperty = newProperty;
 151     DALI_ASSERT_DEBUG(mProperty && "Uninitialized scenegraph property") ;
 152   }
 153
 154   /**
 155    * Constructor for metadata of animatable property
 156    * @param [in] newValue The value of the scene-graph owned property.
 157    */
 158   AnimatablePropertyMetadata( Property::Value newValue )
 159   {
 160     type = newValue.GetType();
 161     value = newValue;
 162   }
 163
 164   /**
 165    * @return true if the property can be written to
 166    */
 167   virtual bool IsWritable(void) const
 168   {
 169     return true ;
 170   }
 171
 172 private:
 173
 174   // Not implemented
 175   AnimatablePropertyMetadata();
 176   AnimatablePropertyMetadata( const AnimatablePropertyMetadata& );
 177   AnimatablePropertyMetadata& operator=( const AnimatablePropertyMetadata& );
 178 };
 179
 180 class CustomPropertyMetadata : public PropertyMetadata
 181 {
 182 public:
 183
 184   /**
 185    * Constructor for metadata of scene graph based properties
 186    * @param [in] newName The name of the custom property.
 187    * @param [in] newType The type ID of the custom property.
 188    * @param [in] newProperty A pointer to the scene-graph owned property.
 189    */
 190   CustomPropertyMetadata( const std::string& newName,
 191                   Property::Type newType,
 192                   const SceneGraph::PropertyBase* newProperty)
 193   : name(newName),
 194     mAccessMode(Property::ANIMATABLE)
 195   {
 196     type = newType;
 197     mProperty = newProperty;
 198     DALI_ASSERT_DEBUG(mProperty && "Uninitialized scenegraph property") ;
 199   }
 200
 201   /**
 202    * Constructor for metadata of event side only properties
 203    * @param [in] newName The name of the custom property.
 204    * @param [in] newValue The value of the custom property.
 205    * @param [in] accessMode The access mode of the custom property (writable, animatable etc).
 206    */
 207   CustomPropertyMetadata( const std::string& newName,
 208                   Property::Value newValue,
 209                   Property::AccessMode accessMode )
 210   : name(newName),
 211     mAccessMode(accessMode)
 212   {
 213     type = newValue.GetType();
 214     value = newValue;
 215     DALI_ASSERT_DEBUG(accessMode != Property::ANIMATABLE && "Animatable must have scenegraph property") ;
 216   }
 217
 218   /**
 219    * @return true if the property can be written to
 220    */
 221   virtual bool IsWritable(void) const
 222   {
 223     return (mAccessMode == Property::ANIMATABLE) || (mAccessMode == Property::READ_WRITE) ;
 224   }
 225
 226   std::string name;       ///< The name of the property
 227
 228 private:
 229
 230   // Not implemented
 231   CustomPropertyMetadata();
 232   CustomPropertyMetadata( const CustomPropertyMetadata& );
 233   CustomPropertyMetadata& operator=( const CustomPropertyMetadata& );
 234
 235 private:
 236   Property::AccessMode mAccessMode; ///< The mode of the property
 237 };
 238
 239 } // namespace Internal
 240
 241 } // namespace Dali
 242
 243 #endif // __DALI_INTERNAL_PROPERTY_METADATA_H__