X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fevent%2Fcommon%2Ftype-registry-impl.h;h=8437ba07762c3bd96c925f72eb3798df4739f7ea;hb=33a8477946185463936981476e9772d40c37fd72;hp=c3f5c906589813881d6f8f54a7d0c06f76a87273;hpb=0495953dba33e35e17d01887f4bf01dc96f7eb4b;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/event/common/type-registry-impl.h b/dali/internal/event/common/type-registry-impl.h index c3f5c90..8437ba0 100644 --- a/dali/internal/event/common/type-registry-impl.h +++ b/dali/internal/event/common/type-registry-impl.h @@ -1,8 +1,8 @@ -#ifndef __DALI_INTERNAL_TYPE_REGISTRY_H__ -#define __DALI_INTERNAL_TYPE_REGISTRY_H__ +#ifndef DALI_INTERNAL_TYPE_REGISTRY_H +#define DALI_INTERNAL_TYPE_REGISTRY_H /* - * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,20 +19,19 @@ */ // INTERNAL INCLUDES -#include -#include +#include +#include +#include +#include #include #include -#include +#include namespace Dali { - namespace Internal { - -//////////////////////////////////////////////////////////////////////////////// -class TypeRegistry; +class PropertyDetails; /* * @copydoc Dali::TypeRegistry @@ -40,64 +39,92 @@ class TypeRegistry; class TypeRegistry : public Dali::BaseObject { public: + // using intrusive pointer instead of handles internally as they are considerably cheaper + using TypeInfoPointer = IntrusivePtr; + /** * Get the TypeRegistry */ - static TypeRegistry *Get(); + static TypeRegistry* Get(); - /* + /** * @copydoc Dali::TypeRegistry::GetTypeInfo */ - Dali::TypeInfo GetTypeInfo( const std::string &uniqueTypeName ); + TypeInfoPointer GetTypeInfo(const std::string& uniqueTypeName); - /* + /** * @copydoc Dali::TypeRegistry::GetTypeInfo */ - Dali::TypeInfo GetTypeInfo( const std::type_info& registerType ); + TypeInfoPointer GetTypeInfo(const std::type_info& registerType); - /* - * @copydoc Dali::TypeRegistry::GetTypeNames + /** + * @copydoc Dali::TypeRegistry::GetTypeNameCount */ - Dali::TypeRegistry::NameContainer GetTypeNames() const; + uint32_t GetTypeNameCount() const; - /* - * Register a creation function under a unique name. + /** + * @copydoc Dali::TypeRegistry::GetTypeName + */ + const std::string& GetTypeName(uint32_t index) const; + + /** + * Register a type + * * @param [in] theTypeInfo Type info for the type to be registered * @param [in] baseTypeInfo Type info for its base class * @param [in] createInstance Instance creation function - * @param [in] callCreateOnInit If true call createInstance on dali initialisation - * @return true if the name could be registered. + * @param [in] callCreateOnInit If true call createInstance on DALi initialisation + * @return the name of the registered type. */ - bool Register( const std::type_info& theTypeInfo, const std::type_info& baseTypeInfo, - Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit ); + std::string Register(const std::type_info& theTypeInfo, const std::type_info& baseTypeInfo, Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit); - /* - * Register a creation function under a unique name. - * @param [in] name The name type to be registered (must be unique) + /** + * Register a type + * + * @param [in] theTypeInfo Type info for the type to be registered * @param [in] baseTypeInfo Type info for its base class * @param [in] createInstance Instance creation function - * @param [in] callCreateOnInit If true call createInstance on dali initialisation - * @return true if the name could be registered. + * @param [in] callCreateOnInit If true call createInstance on DALi initialisation + * @param [in] defaultProperties the table of default property metadata + * @param [in] defaultPropertyCount count of default properties + * @return the name of the registered type. */ - bool Register( const std::string& name, const std::type_info& baseTypeInfo, - Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit ); + std::string Register(const std::type_info& theTypeInfo, const std::type_info& baseTypeInfo, Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit, const Dali::PropertyDetails* defaultProperties, Property::Index defaultPropertyCount); - /* + /** + * Register a type + * + * @param [in] theTypeInfo Type info for the type to be registered + * @param [in] baseTypeInfo Type info for its base class + * @param [in] createInstance Instance creation function + * @param [in] callCreateOnInit If true call createInstance on DALi initialisation + * @param [in] defaultProperties the table of default property metadata + * @param [in] defaultPropertyCount count of default properties + * @return the name of the registered type. + */ + std::string Register(std::string name, const std::type_info& baseTypeInfo, Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit, const Dali::PropertyDetails* defaultProperties = nullptr, Property::Index defaultPropertyCount = 0); + + /** + * @copydoc CSharpTypeRegistry::TypeRegistration( const std::string&, const std::type_info&, TypeInfo::CreateFunction ); + */ + void Register(std::string name, const std::type_info& baseTypeInfo, Dali::CSharpTypeInfo::CreateFunction createInstance); + + /** * Register a signal connector function to a type * @param [in] typeRegistration TypeRegistration object used to register the type * @param [in] name Signal name * @param [in] func Signal connector function */ - void RegisterSignal( TypeRegistration& typeRegistration, const std::string& name, Dali::TypeInfo::SignalConnectorFunction func ); + void RegisterSignal(TypeRegistration& typeRegistration, std::string name, Dali::TypeInfo::SignalConnectorFunction func); - /* + /** * Register an action function to a type * @param [in] registered TypeRegistration object used to register the type * @param [in] name Action name * @param [in] f Action function * @return true if registered */ - bool RegisterAction( TypeRegistration ®istered, const std::string &name, Dali::TypeInfo::ActionFunction f); + bool RegisterAction(TypeRegistration& registered, std::string name, Dali::TypeInfo::ActionFunction f); /** * Register an event-thread only property with a type @@ -109,7 +136,19 @@ public: * @param [in] getFunc The function to get the value of a property. * @return true if registered */ - bool RegisterProperty( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc ); + bool RegisterProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc); + + /** + * Register an event-thread only property with a type (used by C# Custom controls) + * @param [in] objectName name of the object used to register the type + * @param [in] name Property name + * @param [in] index Property index + * @param [in] type Property type + * @param [in] setFunc The function to set the property (Can be NULL). + * @param [in] getFunc The function to get the value of a property. + * @return true if registered + */ + bool RegisterProperty(const std::string& objectName, std::string name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc); /** * Register a scene graph only property with a type @@ -119,7 +158,17 @@ public: * @param [in] type Property type * @return true if registered */ - bool RegisterAnimatableProperty( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type ); + bool RegisterAnimatableProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type); + + /** + * Register a scene graph only property with a default value + * @param [in] registered TypeRegistration object used to register the type + * @param [in] name Property name + * @param [in] index Property index + * @param [in] value Property default value + * @return true if registered + */ + bool RegisterAnimatableProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Value defaultValue); /** * Register a component of a scene graph only property that supports components (i.e. Vector2, Vector3 and Vector4) @@ -130,66 +179,82 @@ public: * @param [in] componentIndex Component index * @return true if registered */ - bool RegisterAnimatablePropertyComponent( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex ); + bool RegisterAnimatablePropertyComponent(TypeRegistration& registered, std::string name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex); - /* + /** + * Register a event-thread only property with a type and a default value + * @param [in] registeredType Name of a registered type on which to register the child property. + * @param [in] name Property name + * @param [in] index Property index + * @param [in] type Property type + * @return true if registered + */ + bool RegisterChildProperty(const std::string& registeredType, std::string name, Property::Index index, Property::Type type); + + /** + * Register a event-thread only property with a type and a default value + * @param [in] registered TypeRegistration object used to register the type + * @param [in] name Property name + * @param [in] index Property index + * @param [in] type Property type + * @return true if registered + */ + bool RegisterChildProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type); + + /** * @copydoc Dali::Internal::TypeInfo::DoActionTo * Walks all base types until it finds a doer. */ - bool DoActionTo( BaseObject * const object, const std::string &actionName, const std::vector &properties); + bool DoActionTo(BaseObject* const object, const std::string& actionName, const Property::Map& properties); /** * @copydoc Dali::BaseHandle::ConnectSignal() */ - bool ConnectSignal( BaseObject* object, ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor ); + bool ConnectSignal(BaseObject* object, ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor); - /* + /** * Return the type info for a given BaseObject pointer * @param [in] pBaseObject Pointer to a BaseObject * @return TypeInfo for the BaseObject. */ - Dali::TypeInfo GetTypeInfo(const Dali::BaseObject * const pBaseObject); + TypeInfoPointer GetTypeInfo(const Dali::BaseObject* const pBaseObject); - /* + /** * Calls any type creation functions that have been flagged as initialization functions */ void CallInitFunctions(void) const; public: - /* * Return the name derived from type_info used to register the type * @param [in] registerType Type info for the type to be registered * @return registered name */ - static std::string RegistrationName( const std::type_info& registerType ); + static std::string RegistrationName(const std::type_info& registerType); private: /* - * Map from type name to TypeInfo + * Mapping from type name to TypeInfo */ - typedef std::map RegistryMap; - RegistryMap mRegistryLut; + Dali::Internal::IndexedConstStringMap mRegistryLut; - typedef std::vector InitFunctions; - InitFunctions mInitFunctions; + std::vector mInitFunctions; private: TypeRegistry(); - ~TypeRegistry(); + ~TypeRegistry() override; /** * @brief Undefined Copy Constructor */ - TypeRegistry(TypeRegistry &); + TypeRegistry(TypeRegistry&); /** * @brief Undefined Assignment Operator */ - TypeRegistry& operator=(const TypeRegistry &); + TypeRegistry& operator=(const TypeRegistry&); }; - } // namespace Internal // Helpers for public-api forwarding methods @@ -214,4 +279,4 @@ inline const Internal::TypeRegistry& GetImplementation(const Dali::TypeRegistry& } // namespace Dali -#endif // __DALI_INTERNAL_TYPE_REGISTRY_H__ +#endif // DALI_INTERNAL_TYPE_REGISTRY_H