dali/internal/event/common/type-registry-impl.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/event/common/type-registry-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/internal/event/common/thread-local-storage.h>
  23 #include <dali/public-api/object/type-registry.h>
  24 #include <dali/public-api/object/base-handle.h>
  25 #include <dali/internal/event/actors/custom-actor-internal.h>
  26 #include <dali/internal/event/common/demangler.h>
  27
  28 #include <dali/integration-api/debug.h>
  29
  30 namespace
  31 {
  32
  33 #if defined(DEBUG_ENABLED)
  34 Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_TYPE_REGISTRY");
  35 #endif
  36
  37 } // namespace anon
  38
  39 namespace Dali
  40 {
  41
  42 extern std::string Demangle(const char* symbol);
  43
  44 namespace Internal
  45 {
  46
  47 TypeRegistry *TypeRegistry::Get()
  48 {
  49   static TypeRegistry *_reg(new TypeRegistry());
  50   DALI_ASSERT_DEBUG(_reg);
  51   return _reg;
  52 }
  53
  54 TypeRegistry::TypeRegistry()
  55 {
  56
  57 }
  58
  59 TypeRegistry::~TypeRegistry()
  60 {
  61   mRegistryLut.clear();
  62 }
  63
  64 TypeRegistry::TypeInfoPointer TypeRegistry::GetTypeInfo( const std::string& uniqueTypeName )
  65 {
  66   for( auto&& iter : mRegistryLut )
  67   {
  68     // Note! mRegistryLut contains Dali::TypeInfo handles, so cannot call GetTypeName()
  69     // as it calls us back resulting in infinite loop (GetTypeName is in BaseHandle part)
  70     if( iter->GetName() == uniqueTypeName )
  71     {
  72       return iter;
  73     }
  74   }
  75   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Cannot find requested type '%s'\n", uniqueTypeName.c_str() );
  76
  77   return TypeRegistry::TypeInfoPointer();
  78 }
  79
  80 TypeRegistry::TypeInfoPointer TypeRegistry::GetTypeInfo( const std::type_info& registerType )
  81 {
  82   std::string typeName = DemangleClassName( registerType.name() );
  83
  84   return GetTypeInfo( typeName );
  85 }
  86
  87 size_t TypeRegistry::GetTypeNameCount() const
  88 {
  89   return mRegistryLut.size();
  90 }
  91
  92 std::string TypeRegistry::GetTypeName( size_t index ) const
  93 {
  94   std::string name;
  95
  96   if( index < mRegistryLut.size() )
  97   {
  98     name = mRegistryLut[ index ]->GetName();
  99   }
 100
 101   return name;
 102 }
 103
 104 std::string TypeRegistry::Register( const std::type_info& theTypeInfo, const std::type_info& baseTypeInfo,
 105                              Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit )
 106 {
 107   std::string uniqueTypeName  = DemangleClassName( theTypeInfo.name() );
 108
 109   return Register( uniqueTypeName, baseTypeInfo, createInstance, callCreateOnInit );
 110 }
 111
 112 std::string TypeRegistry::Register( const std::type_info& theTypeInfo, const std::type_info& baseTypeInfo,
 113                              Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit,
 114                              const Dali::PropertyDetails* defaultProperties, Property::Index defaultPropertyCount )
 115 {
 116   std::string uniqueTypeName  = DemangleClassName( theTypeInfo.name() );
 117
 118   return Register( uniqueTypeName, baseTypeInfo, createInstance, callCreateOnInit, defaultProperties, defaultPropertyCount );
 119 }
 120
 121 std::string TypeRegistry::Register( const std::string& uniqueTypeName, const std::type_info& baseTypeInfo,
 122                              Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit,
 123                              const Dali::PropertyDetails* defaultProperties, Property::Index defaultPropertyCount )
 124 {
 125   std::string baseTypeName = DemangleClassName( baseTypeInfo.name() );
 126
 127   // check for duplicates using uniqueTypeName
 128   for( auto&& iter : mRegistryLut )
 129   {
 130     if( iter->GetName() == uniqueTypeName )
 131     {
 132       DALI_LOG_WARNING( "Duplicate name in TypeRegistry for '%s'\n", + uniqueTypeName.c_str() );
 133       DALI_ASSERT_ALWAYS( !"Duplicate type name in Type Registration" );
 134       return uniqueTypeName; // never actually happening due to the assert
 135     }
 136   }
 137
 138   mRegistryLut.push_back( TypeRegistry::TypeInfoPointer( new Internal::TypeInfo( uniqueTypeName, baseTypeName, createInstance, defaultProperties, defaultPropertyCount ) ) );
 139   DALI_LOG_INFO( gLogFilter, Debug::Concise, "Type Registration %s(%s)\n", uniqueTypeName.c_str(), baseTypeName.c_str() );
 140
 141   if( callCreateOnInit )
 142   {
 143     mInitFunctions.push_back(createInstance);
 144   }
 145
 146   return uniqueTypeName;
 147 }
 148
 149 void TypeRegistry::Register( const std::string& uniqueTypeName, const std::type_info& baseTypeInfo,
 150     Dali::CSharpTypeInfo::CreateFunction createInstance )
 151 {
 152   std::string baseTypeName = DemangleClassName( baseTypeInfo.name() );
 153
 154   // check for duplicates using uniqueTypeName
 155   for( auto&& iter : mRegistryLut )
 156   {
 157     if( iter->GetName() == uniqueTypeName )
 158     {
 159       DALI_LOG_WARNING( "Duplicate name in TypeRegistry for '%s'\n", + uniqueTypeName.c_str() );
 160       DALI_ASSERT_ALWAYS( !"Duplicate type name in Type Registration" );
 161       return; // never actually happening due to the assert
 162     }
 163   }
 164
 165   mRegistryLut.push_back( TypeRegistry::TypeInfoPointer( new Internal::TypeInfo( uniqueTypeName, baseTypeName, createInstance ) ) );
 166   DALI_LOG_INFO( gLogFilter, Debug::Concise, "Type Registration %s(%s)\n", uniqueTypeName.c_str(), baseTypeName.c_str() );
 167 }
 168
 169 void TypeRegistry::CallInitFunctions(void) const
 170 {
 171   for( auto&& iter : mInitFunctions )
 172   {
 173     (*iter)();
 174   }
 175 }
 176
 177 std::string TypeRegistry::RegistrationName( const std::type_info& registerType )
 178 {
 179   return DemangleClassName( registerType.name() );
 180 }
 181
 182 void TypeRegistry::RegisterSignal( TypeRegistration& typeRegistration, const std::string& name, Dali::TypeInfo::SignalConnectorFunction func )
 183 {
 184   for( auto&& iter : mRegistryLut )
 185   {
 186     if( iter->GetName() == typeRegistration.RegisteredName() )
 187     {
 188       iter->AddConnectorFunction( name, func );
 189       break;
 190     }
 191   }
 192 }
 193
 194 bool TypeRegistry::RegisterAction( TypeRegistration& typeRegistration, const std::string &name, Dali::TypeInfo::ActionFunction f )
 195 {
 196   for( auto&& iter : mRegistryLut )
 197   {
 198     if( iter->GetName() == typeRegistration.RegisteredName() )
 199     {
 200       iter->AddActionFunction( name, f );
 201       return true;
 202     }
 203   }
 204   return false;
 205 }
 206
 207 bool TypeRegistry::RegisterProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc )
 208 {
 209   for( auto&& iter : mRegistryLut )
 210   {
 211     if( iter->GetName() == typeRegistration.RegisteredName() )
 212     {
 213       iter->AddProperty( name, index, type, setFunc, getFunc );
 214       return true;
 215     }
 216   }
 217
 218   return false;
 219 }
 220
 221 bool TypeRegistry::RegisterProperty( const std::string& objectName, const std::string& name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc )
 222 {
 223   for( auto&& iter : mRegistryLut )
 224   {
 225     if( iter->GetName() == objectName )
 226     {
 227       iter->AddProperty( name, index, type, setFunc, getFunc );
 228       return true;
 229     }
 230   }
 231
 232   return false;
 233 }
 234
 235
 236 bool TypeRegistry::RegisterAnimatableProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Type type )
 237 {
 238   for( auto&& iter : mRegistryLut )
 239   {
 240     if( iter->GetName() == typeRegistration.RegisteredName() )
 241     {
 242       iter->AddAnimatableProperty( name, index, type );
 243       return true;
 244     }
 245   }
 246
 247   return false;
 248 }
 249
 250 bool TypeRegistry::RegisterAnimatableProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, const Property::Value& value )
 251 {
 252   for( auto&& iter : mRegistryLut )
 253   {
 254     if( iter->GetName() == typeRegistration.RegisteredName() )
 255     {
 256       iter->AddAnimatableProperty( name, index, value );
 257       return true;
 258     }
 259   }
 260
 261   return false;
 262 }
 263
 264 bool TypeRegistry::RegisterAnimatablePropertyComponent( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex )
 265 {
 266   for( auto&& iter : mRegistryLut )
 267   {
 268     if( iter->GetName() == typeRegistration.RegisteredName() )
 269     {
 270       iter->AddAnimatablePropertyComponent( name, index, baseIndex, componentIndex );
 271       return true;
 272     }
 273   }
 274
 275   return false;
 276 }
 277
 278 bool TypeRegistry::RegisterChildProperty( const std::string& registeredType, const std::string& name, Property::Index index, Property::Type type )
 279 {
 280   for( auto&& iter : mRegistryLut )
 281   {
 282     if( iter->GetName() == registeredType )
 283     {
 284       iter->AddChildProperty( name, index, type );
 285       return true;
 286     }
 287   }
 288
 289   return false;
 290 }
 291
 292 bool TypeRegistry::RegisterChildProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Type type )
 293 {
 294   return RegisterChildProperty( typeRegistration.RegisteredName(), name, index, type );
 295 }
 296
 297 bool TypeRegistry::DoActionTo( BaseObject * const object, const std::string& actionName, const Property::Map& properties )
 298 {
 299   bool done = false;
 300
 301   auto&& type = GetTypeInfo( object );
 302
 303   // DoActionTo recurses through base classes
 304   done = type->DoActionTo( object, actionName, properties );
 305
 306   if( !done )
 307   {
 308     DALI_LOG_WARNING("Type '%s' cannot do action '%s'\n", type->GetName().c_str(), actionName.c_str());
 309   }
 310
 311   return done;
 312 }
 313
 314 bool TypeRegistry::ConnectSignal( BaseObject* object, ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor )
 315 {
 316   bool connected( false );
 317
 318   auto&& type = GetTypeInfo( object );
 319
 320   // Connect iterates through base classes
 321   connected = type->ConnectSignal( object, connectionTracker, signalName, functor );
 322
 323   if( !connected )
 324   {
 325     DALI_LOG_WARNING("Type '%s' signal '%s' connection failed \n", type->GetName().c_str(), signalName.c_str());
 326     // Ownership of functor was not passed to Dali::CallbackBase, so clean-up now
 327     delete functor;
 328   }
 329
 330   return connected;
 331 }
 332
 333 TypeRegistry::TypeInfoPointer TypeRegistry::GetTypeInfo(const Dali::BaseObject * const pBaseObject)
 334 {
 335   TypeInfoPointer type;
 336
 337   // test for custom actor which has another indirection to get to the type hiearchy we're after
 338   const Dali::Internal::CustomActor * const pCustom = dynamic_cast<const Dali::Internal::CustomActor*>(pBaseObject);
 339
 340   if( pCustom )
 341   {
 342     const Dali::CustomActorImpl& custom = pCustom->GetImplementation();
 343     type = GetTypeInfo( typeid( custom ) );
 344     if( !type )
 345     {
 346       // the most derived type is a descendant of custom actor but has not registered itself
 347       // so we'll just treat it as a custom actor for now so it "inherits" all of actors properties, actions and signals
 348       type = GetTypeInfo( typeid( Dali::Internal::CustomActor ) );
 349     }
 350   }
 351   else
 352   {
 353     type = GetTypeInfo( typeid( *pBaseObject ) );
 354   }
 355
 356   return type;
 357 }
 358
 359 } // namespace Internal
 360
 361 } // namespace Dali