1 #ifndef __DALI_TYPE_REGISTRY_H__
2 #define __DALI_TYPE_REGISTRY_H__
5 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 #include <dali/public-api/object/base-handle.h>
27 #include <dali/public-api/object/type-info.h>
29 namespace Dali DALI_IMPORT_API
32 namespace Internal DALI_INTERNAL
38 * @brief The TypeRegistry allows registration of type instance creation functions.
40 * These can then be created later by name and down cast to the appropriate type.
42 * Usage: (Registering)
46 * // Note: object construction in namespace scope is defined in a translation unit as being
47 * // in appearance order (C++ standard 3.6/2). So TypeRegistration is declared first in
48 * // the cpp file below. Signal, action and property declarations follow in any order.
51 * TypeRegistration myActorType(typeid(MyActor), typeid(Actor), CreateMyActor );
53 * SignalConnectorType( myActorType, "highlighted", ConnectSignalForMyActor );
54 * TypeAction( myActorType, "open", DoMyActorAction );
55 * TypeAction( myActorType, "close", DoMyActorAction );
56 * PropertyRegistration( myActorType, "status", PropertyRegistration::START_INDEX, Property::BOOLEAN, SetPropertyFunction, GetPropertyFunction );
63 * TypeRegistry::TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyActor");
64 * MyActor a = MyActor::DownCast(type.CreateInstance());
73 * Actors that inherit from the CustomActor framework must ensure the implementation
74 * class has an identical name to the Actor class. This is to ensure the class can be
75 * found at runtime for signals and actions. Otherwise these will silently fail.
77 * As namespaces are discarded the convention is to use a namespace ie
79 * 'class MyActor {}; namespace Internal { class MyActor {}; }'
81 * Warning: this arrangement will silently fail
83 * 'class MyActor {}; class MyActorImpl {};'
87 * Signal and action names follow properties and are by convention lower case hyphen
88 * separated ie 'next-page'. This maintains consistency with the scripted interface.
91 class TypeRegistry : public BaseHandle
94 typedef std::vector<std::string> NameContainer; ///< Container of type names
97 * @brief Get Type Registry handle.
99 * @return TypeRegistry handle
101 static TypeRegistry Get();
104 * @brief Allows the creation of an empty typeRegistry handle.
114 * @copydoc Dali::BaseHandle::operator=
116 using BaseHandle::operator=;
119 * @brief Get TypeInfo for a registered type.
121 * @param [in] uniqueTypeName A unique type name
122 * @return TypeInfo if the type exists otherwise an empty handle
124 TypeInfo GetTypeInfo( const std::string &uniqueTypeName );
127 * @brief Get TypeInfo for a registered type.
129 * @param [in] registerType The registered type info
130 * @return TypeInfo if the type exists otherwise an empty handle
132 TypeInfo GetTypeInfo( const std::type_info& registerType );
135 * @brief Get type names.
137 * @return list of known types by name
139 NameContainer GetTypeNames() const;
141 public: // Not intended for application developers
144 * @brief This constructor is used by Dali Get() method.
146 * @param [in] typeRegistry A pointer to a Dali resource
148 explicit DALI_INTERNAL TypeRegistry(Internal::TypeRegistry*typeRegistry);
152 * @brief Register a type from type info.
154 class TypeRegistration
158 * @brief Constructor registers the type creation function.
160 * @param [in] registerType the type info for the type to be registered
161 * @param [in] baseType the base type info of registerType
162 * @param [in] f registerType instance creation function
164 TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
165 TypeInfo::CreateFunction f );
168 * @brief Constructor registers the type creation function.
170 * @param [in] registerType the type info for the type to be registered
171 * @param [in] baseType the base type info of registerType
172 * @param [in] f registerType instance creation function
173 * @param [in] callCreateOnInit If true the creation function is called as part of Dali initialisation
175 TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
176 TypeInfo::CreateFunction f, bool callCreateOnInit );
179 * @brief Constructor registers the type creation function for a named class or type.
181 * This allows types to be created dynamically from script. The name must be
182 * unique for successful registration.
183 * @param [in] name the name of the type to be registered
184 * @param [in] baseType the base type info of registerType
185 * @param [in] f registerType instance creation function
187 TypeRegistration( const std::string& name, const std::type_info& baseType,
188 TypeInfo::CreateFunction f );
191 * @brief The name the type is registered under (derived from type_info).
193 * @return the registered name or empty if unregistered
195 const std::string RegisteredName() const;
198 TypeRegistry mReference; ///< Reference to the type registry
199 std::string mName; ///< Name of the type
203 * @brief Register a signal connector function to a registered type.
205 class SignalConnectorType
209 * @brief Constructor registers the type creation function.
211 * @param [in] typeRegistration The TypeRegistration object
212 * @param [in] name The signal name
213 * @param [in] func The signal connector function
215 SignalConnectorType( TypeRegistration& typeRegistration, const std::string& name, TypeInfo::SignalConnectorFunctionV2 func );
219 * @brief Register an action function.
225 * @brief Constructor registers the type creation function.
227 * @param [in] registered The TypeRegistration object
228 * @param [in] name The action name
229 * @param [in] f The action function
231 TypeAction( TypeRegistration ®istered, const std::string &name, TypeInfo::ActionFunction f);
235 * @brief Register a property for the given type.
237 class PropertyRegistration
242 * @brief This constructor registers the property with the registered type.
244 * This constructor is for event-thread only properties where the
245 * value of the property can be retrieved and set via specified
248 * Functions of the following type may be used for setFunc and getFunc respectively:
250 * void SetProperty( BaseObject* object, Property::Index index, const Property::Value& value );
251 * Property::Value GetProperty( BaseObject* object, Property::Index index );
254 * @param [in] registered The TypeRegistration object
255 * @param [in] name The name of the property
256 * @param [in] index The property index. Must be a value between PROPERTY_REGISTRATION_START_INDEX and PROPERTY_REGISTRATION_MAX_INDEX inclusive.
257 * @param [in] type The property value type.
258 * @param [in] setFunc The function to call when setting the property. If NULL, then the property becomes read-only.
259 * @param [in] getFunc The function to call to retrieve the current value of the property. MUST be provided.
261 * @note The "index" value must be between START_INDEX and MAX_INDEX inclusive.
262 * @note If "setFunc" is NULL, then the property becomes a read-only property.
263 * @note "getFunc" MUST be provided
265 * @pre "registered" must be registered with the TypeRegistry.
267 PropertyRegistration( TypeRegistration& registered,
268 const std::string& name, Property::Index index, Property::Type type,
269 TypeInfo::SetPropertyFunction setFunc, TypeInfo::GetPropertyFunction getFunc );