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

   1 /*
   2  * Copyright (c) 2014 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-info-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm> // std::find_if
  23 #include <string>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/integration-api/debug.h>
  27 #include <dali/internal/event/common/type-registry-impl.h>
  28 #include <dali/internal/event/common/object-impl.h>
  29
  30 using std::find_if;
  31
  32 namespace
  33 {
  34
  35 /*
  36  * Functor to find by given type for vector of pairs
  37  */
  38 template <typename S, typename T>
  39 struct PairFinder
  40 {
  41   PairFinder(const S& find)
  42   : mFind(find)
  43   {
  44   }
  45
  46   bool operator()(const T& p) const
  47   {
  48     return p.first == mFind;
  49   }
  50
  51 private:
  52
  53   const S& mFind;
  54 };
  55
  56 /**
  57  * Functor to find a matching property name
  58  */
  59 template <typename T>
  60 struct PropertyNameFinder
  61 {
  62   PropertyNameFinder( const std::string& find )
  63   : mFind( find )
  64   {
  65   }
  66
  67   bool operator()(const T &p) const
  68   {
  69     return p.second.name == mFind;
  70   }
  71
  72 private:
  73
  74   const std::string& mFind;
  75 };
  76
  77 } // namespace anon
  78
  79 namespace Dali
  80 {
  81
  82 namespace Internal
  83 {
  84
  85 TypeInfo::TypeInfo(const std::string &name, const std::string &baseTypeName, Dali::TypeInfo::CreateFunction creator)
  86   : mTypeName(name), mBaseTypeName(baseTypeName), mCreate(creator)
  87 {
  88   DALI_ASSERT_ALWAYS(!name.empty() && "Type info construction must have a name");
  89   DALI_ASSERT_ALWAYS(!baseTypeName.empty() && "Type info construction must have a base type name");
  90 }
  91
  92 TypeInfo::~TypeInfo()
  93 {
  94 }
  95
  96 BaseHandle TypeInfo::CreateInstance() const
  97 {
  98   BaseHandle ret;
  99
 100   if(mCreate)
 101   {
 102     ret = mCreate();
 103
 104     if ( ret )
 105     {
 106       BaseObject& handle = ret.GetBaseObject();
 107       Object *object = dynamic_cast<Internal::Object*>(&handle);
 108
 109       if ( object )
 110       {
 111         object->SetTypeInfo( this );
 112       }
 113     }
 114   }
 115   return ret;
 116 }
 117
 118 bool TypeInfo::DoActionTo(BaseObject *object, const std::string &actionName, const std::vector<Property::Value> &properties)
 119 {
 120   bool done = false;
 121
 122   ActionContainer::iterator iter = find_if(mActions.begin(), mActions.end(), PairFinder<std::string, ActionPair>(actionName));
 123
 124   if( iter != mActions.end() )
 125   {
 126     done = (iter->second)(object, actionName, properties);
 127   }
 128   else
 129   {
 130     DALI_LOG_WARNING("Type '%s' cannot do action '%s'\n", mTypeName.c_str(), actionName.c_str());
 131   }
 132
 133   if(!done)
 134   {
 135     Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 136     while( base )
 137     {
 138       done = GetImplementation(base).DoActionTo(object, actionName, properties);
 139       if( done )
 140       {
 141         break;
 142       }
 143       base =  Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 144     }
 145   }
 146
 147   return done;
 148 }
 149
 150 bool TypeInfo::ConnectSignal( BaseObject* object, ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor )
 151 {
 152   bool connected( false );
 153
 154   ConnectorContainer::iterator iter = find_if( mSignalConnectors.begin(), mSignalConnectors.end(),
 155                                                  PairFinder<std::string, ConnectionPair>(signalName) );
 156
 157   if( iter != mSignalConnectors.end() )
 158   {
 159     connected = (iter->second)( object, connectionTracker, signalName, functor );
 160   }
 161
 162   return connected;
 163 }
 164
 165 const std::string& TypeInfo::GetName() const
 166 {
 167   return mTypeName;
 168 }
 169
 170 const std::string& TypeInfo::GetBaseName() const
 171 {
 172   return mBaseTypeName;
 173 }
 174
 175 Dali::TypeInfo::CreateFunction TypeInfo::GetCreator() const
 176 {
 177   return mCreate;
 178 }
 179
 180 void TypeInfo::GetActions( Dali::TypeInfo::NameContainer& ret ) const
 181 {
 182   for(ActionContainer::const_iterator iter = mActions.begin(); iter != mActions.end(); ++iter)
 183   {
 184     ret.push_back(iter->first);
 185   }
 186
 187   Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 188   while( base )
 189   {
 190     for(ActionContainer::const_iterator iter = GetImplementation(base).mActions.begin();
 191         iter != GetImplementation(base).mActions.end(); ++iter)
 192     {
 193       ret.push_back(iter->first);
 194     }
 195
 196     base = Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 197   }
 198 }
 199
 200 void TypeInfo::GetSignals(Dali::TypeInfo::NameContainer& ret) const
 201 {
 202   for(ConnectorContainer::const_iterator iter = mSignalConnectors.begin(); iter != mSignalConnectors.end(); ++iter)
 203   {
 204     ret.push_back(iter->first);
 205   }
 206
 207   Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 208   while( base )
 209   {
 210     for(ConnectorContainer::const_iterator iter = GetImplementation(base).mSignalConnectors.begin();
 211         iter != GetImplementation(base).mSignalConnectors.end(); ++iter)
 212     {
 213       ret.push_back(iter->first);
 214     }
 215
 216     base = Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 217   }
 218 }
 219
 220 void TypeInfo::GetProperties( Dali::TypeInfo::NameContainer& ret ) const
 221 {
 222   Property::IndexContainer indices;
 223
 224   GetPropertyIndices(indices);
 225
 226   ret.reserve(indices.size());
 227
 228   for(Property::IndexContainer::iterator iter = indices.begin(); iter != indices.end(); ++iter)
 229   {
 230     const std::string& name = GetPropertyName( *iter );
 231     if(name.size())
 232     {
 233       ret.push_back( name );
 234     }
 235     else
 236     {
 237       DALI_LOG_WARNING("Property had no name\n");
 238     }
 239   }
 240 }
 241
 242 void TypeInfo::GetPropertyIndices( Property::IndexContainer& indices ) const
 243 {
 244   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 245   if ( base )
 246   {
 247     const TypeInfo& baseImpl( GetImplementation( base ) );
 248     baseImpl.GetPropertyIndices( indices );
 249   }
 250
 251   if ( ! mRegisteredProperties.empty() )
 252   {
 253     indices.reserve( indices.size() + mRegisteredProperties.size() );
 254
 255     const RegisteredPropertyContainer::const_iterator endIter = mRegisteredProperties.end();
 256     for ( RegisteredPropertyContainer::const_iterator iter = mRegisteredProperties.begin(); iter != endIter; ++iter )
 257     {
 258       indices.push_back( iter->first );
 259     }
 260   }
 261 }
 262
 263 const std::string& TypeInfo::GetPropertyName( Property::Index index ) const
 264 {
 265   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 266                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 267
 268   if ( iter != mRegisteredProperties.end() )
 269   {
 270     return iter->second.name;
 271   }
 272
 273   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 274   if ( base )
 275   {
 276     return GetImplementation(base).GetPropertyName( index );
 277   }
 278
 279   DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 280 }
 281
 282 void TypeInfo::AddActionFunction( const std::string &actionName, Dali::TypeInfo::ActionFunction function )
 283 {
 284   if( NULL == function)
 285   {
 286     DALI_LOG_WARNING("Action function is empty\n");
 287   }
 288   else
 289   {
 290     ActionContainer::iterator iter = std::find_if(mActions.begin(), mActions.end(),
 291                                                   PairFinder<std::string, ActionPair>(actionName));
 292
 293     if( iter == mActions.end() )
 294     {
 295       mActions.push_back( ActionPair( actionName, function ) );
 296     }
 297     else
 298     {
 299       DALI_LOG_WARNING("Action already exists in TypeRegistry Type", actionName.c_str());
 300     }
 301   }
 302 }
 303
 304 void TypeInfo::AddConnectorFunction( const std::string& signalName, Dali::TypeInfo::SignalConnectorFunction function )
 305 {
 306   if( NULL == function)
 307   {
 308     DALI_LOG_WARNING("Connector function is empty\n");
 309   }
 310   else
 311   {
 312     ConnectorContainer::iterator iter = find_if( mSignalConnectors.begin(), mSignalConnectors.end(),
 313                                                    PairFinder<std::string, ConnectionPair>(signalName) );
 314
 315     if( iter == mSignalConnectors.end() )
 316     {
 317       mSignalConnectors.push_back( ConnectionPair( signalName, function ) );
 318     }
 319     else
 320     {
 321       DALI_LOG_WARNING("Signal name already exists in TypeRegistry Type for signal connector function", signalName.c_str());
 322     }
 323   }
 324 }
 325
 326 void TypeInfo::AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc )
 327 {
 328   // The setter can be empty as a property can be read-only.
 329
 330   if ( NULL == getFunc )
 331   {
 332     DALI_ASSERT_ALWAYS( ! "GetProperty Function is empty" );
 333   }
 334   else
 335   {
 336     RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 337                                                           PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 338
 339     if ( iter == mRegisteredProperties.end() )
 340     {
 341       mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, setFunc, getFunc, name ) ) );
 342     }
 343     else
 344     {
 345       DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 346     }
 347   }
 348 }
 349
 350 void TypeInfo::AddAnimatableProperty( const std::string& name, Property::Index index, Property::Type type )
 351 {
 352   RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 353                                                         PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 354
 355   if ( iter == mRegisteredProperties.end() )
 356   {
 357     mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, NULL, NULL, name ) ) );
 358   }
 359   else
 360   {
 361     DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 362   }
 363 }
 364
 365 unsigned int TypeInfo::GetPropertyCount() const
 366 {
 367   unsigned int count( mRegisteredProperties.size() );
 368
 369   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 370   while ( base )
 371   {
 372     const TypeInfo& baseImpl( GetImplementation(base) );
 373     count += baseImpl.mRegisteredProperties.size();
 374     base = TypeRegistry::Get()->GetTypeInfo( baseImpl.mBaseTypeName );
 375   }
 376
 377   return count;
 378 }
 379
 380 Property::Index TypeInfo::GetPropertyIndex( const std::string& name ) const
 381 {
 382   Property::Index index = Property::INVALID_INDEX;
 383
 384   // Slow but should not be done that often
 385   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 386                                                           PropertyNameFinder< RegisteredPropertyPair >( name ) );
 387
 388   if ( iter != mRegisteredProperties.end() )
 389   {
 390     index = iter->first;
 391   }
 392   else
 393   {
 394     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 395     if ( base )
 396     {
 397       index = GetImplementation(base).GetPropertyIndex( name );
 398     }
 399   }
 400
 401   return index;
 402 }
 403
 404 bool TypeInfo::IsPropertyWritable( Property::Index index ) const
 405 {
 406   bool writable( false );
 407
 408   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 409                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 410
 411   if ( iter != mRegisteredProperties.end() )
 412   {
 413     if( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) )
 414     {
 415       writable = true; // animatable property is writable
 416     }
 417     else
 418     {
 419       writable = iter->second.setFunc ? true : false;
 420     }
 421   }
 422   else
 423   {
 424     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 425     if ( base )
 426     {
 427       writable = GetImplementation(base).IsPropertyWritable( index );
 428     }
 429     else
 430     {
 431       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 432     }
 433   }
 434
 435   return writable;
 436 }
 437
 438 Property::Type TypeInfo::GetPropertyType( Property::Index index ) const
 439 {
 440   Property::Type type( Property::NONE );
 441
 442   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 443                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 444
 445   if ( iter != mRegisteredProperties.end() )
 446   {
 447     type = iter->second.type;
 448   }
 449   else
 450   {
 451     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 452     if ( base )
 453     {
 454       type = GetImplementation(base).GetPropertyType( index );
 455     }
 456     else
 457     {
 458       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 459     }
 460   }
 461
 462   return type;
 463 }
 464
 465 void TypeInfo::SetProperty( BaseObject *object, Property::Index index, const Property::Value& value ) const
 466 {
 467   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 468                                                               PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 469   if ( iter != mRegisteredProperties.end() )
 470   {
 471     if( iter->second.setFunc )
 472     {
 473       iter->second.setFunc( object, index, value );
 474     }
 475   }
 476   else
 477   {
 478     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 479     if ( base )
 480     {
 481       GetImplementation(base).SetProperty( object, index, value );
 482     }
 483     else
 484     {
 485       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 486     }
 487   }
 488 }
 489
 490 void TypeInfo::SetProperty( BaseObject *object, const std::string& name, const Property::Value& value ) const
 491 {
 492   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 493                                                               PropertyNameFinder< RegisteredPropertyPair >( name ) );
 494   if ( iter != mRegisteredProperties.end() )
 495   {
 496     DALI_ASSERT_ALWAYS( iter->second.setFunc && "Trying to write to a read-only property" );
 497     iter->second.setFunc( object, iter->first, value );
 498   }
 499   else
 500   {
 501     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 502     if ( base )
 503     {
 504       GetImplementation(base).SetProperty( object, name, value );
 505     }
 506     else
 507     {
 508       DALI_ASSERT_ALWAYS( ! "Cannot find property name" );
 509     }
 510   }
 511 }
 512
 513 Property::Value TypeInfo::GetProperty( const BaseObject *object, Property::Index index ) const
 514 {
 515   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 516                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 517   if( iter != mRegisteredProperties.end() )
 518   {
 519     // Need to remove the constness here as CustomActor will not be able to call Downcast with a const pointer to the object
 520     return iter->second.getFunc( const_cast< BaseObject* >( object ), index );
 521   }
 522
 523   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 524   if ( base )
 525   {
 526     return GetImplementation( base ).GetProperty( object, index );
 527   }
 528
 529   DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 530 }
 531
 532 Property::Value TypeInfo::GetProperty( const BaseObject *object, const std::string& name ) const
 533 {
 534   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 535                                                           PropertyNameFinder< RegisteredPropertyPair >( name ) );
 536   if( iter != mRegisteredProperties.end() )
 537   {
 538     // Need to remove the constness here as CustomActor will not be able to call Downcast with a const pointer to the object
 539     return iter->second.getFunc( const_cast< BaseObject* >( object ), iter->first );
 540   }
 541
 542   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 543   if ( base )
 544   {
 545     return GetImplementation( base ).GetProperty( object, name );
 546   }
 547
 548   DALI_ASSERT_ALWAYS( ! "Cannot find property name" );
 549 }
 550
 551 } // namespace Internal
 552
 553 } // namespace Dali