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

   1 /*
   2  * Copyright (c) 2016 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 /**
  78  * Functor to find a matching property component index
  79  */
  80 template <typename T>
  81 struct PropertyComponentFinder
  82 {
  83   PropertyComponentFinder( Dali::Property::Index basePropertyIndex, const int find )
  84   : mBasePropertyIndex( basePropertyIndex ),
  85     mFind( find )
  86   {
  87   }
  88
  89   bool operator()(const T &p) const
  90   {
  91     return ( p.second.basePropertyIndex == mBasePropertyIndex && p.second.componentIndex == mFind );
  92   }
  93
  94 private:
  95
  96   Dali::Property::Index mBasePropertyIndex;
  97   const int mFind;
  98 };
  99
 100 } // namespace anon
 101
 102 namespace Dali
 103 {
 104
 105 namespace Internal
 106 {
 107
 108 TypeInfo::TypeInfo(const std::string &name, const std::string &baseTypeName, Dali::TypeInfo::CreateFunction creator)
 109   : mTypeName(name), mBaseTypeName(baseTypeName), mCSharpType(false), mCreate(creator)
 110 {
 111   DALI_ASSERT_ALWAYS(!name.empty() && "Type info construction must have a name");
 112   DALI_ASSERT_ALWAYS(!baseTypeName.empty() && "Type info construction must have a base type name");
 113 }
 114
 115 TypeInfo::TypeInfo(const std::string &name, const std::string &baseTypeName, Dali::CSharpTypeInfo::CreateFunction creator)
 116   : mTypeName(name), mBaseTypeName(baseTypeName), mCSharpType(true), mCSharpCreate(creator)
 117 {
 118   DALI_ASSERT_ALWAYS(!name.empty() && "Type info construction must have a name");
 119   DALI_ASSERT_ALWAYS(!baseTypeName.empty() && "Type info construction must have a base type name");
 120 }
 121
 122 TypeInfo::~TypeInfo()
 123 {
 124 }
 125
 126 BaseHandle TypeInfo::CreateInstance() const
 127 {
 128   BaseHandle ret;
 129
 130   if(mCreate)
 131   {
 132     if ( mCSharpType )
 133     {
 134       // CSharp currently only registers one create function for all custom controls
 135       // it uses the type name to decide which one to create
 136       ret = *mCSharpCreate( mTypeName.c_str() );
 137     }
 138     else
 139     {
 140       ret = mCreate();
 141     }
 142
 143     if ( ret )
 144     {
 145       BaseObject& handle = ret.GetBaseObject();
 146       Object *object = dynamic_cast<Internal::Object*>(&handle);
 147
 148       if ( object )
 149       {
 150         object->SetTypeInfo( this );
 151       }
 152     }
 153   }
 154   return ret;
 155 }
 156
 157   bool TypeInfo::DoActionTo(BaseObject *object, const std::string &actionName, const Property::Map &properties)
 158 {
 159   bool done = false;
 160
 161   ActionContainer::iterator iter = find_if(mActions.begin(), mActions.end(), PairFinder<std::string, ActionPair>(actionName));
 162
 163   if( iter != mActions.end() )
 164   {
 165     done = (iter->second)(object, actionName, properties);
 166   }
 167   else
 168   {
 169     DALI_LOG_WARNING("Type '%s' cannot do action '%s'\n", mTypeName.c_str(), actionName.c_str());
 170   }
 171
 172   if(!done)
 173   {
 174     Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 175     while( base )
 176     {
 177       done = GetImplementation(base).DoActionTo(object, actionName, properties);
 178       if( done )
 179       {
 180         break;
 181       }
 182       base =  Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 183     }
 184   }
 185
 186   return done;
 187 }
 188
 189 bool TypeInfo::ConnectSignal( BaseObject* object, ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor )
 190 {
 191   bool connected( false );
 192
 193   ConnectorContainer::iterator iter = find_if( mSignalConnectors.begin(), mSignalConnectors.end(),
 194                                                  PairFinder<std::string, ConnectionPair>(signalName) );
 195
 196   if( iter != mSignalConnectors.end() )
 197   {
 198     connected = (iter->second)( object, connectionTracker, signalName, functor );
 199   }
 200
 201   return connected;
 202 }
 203
 204 const std::string& TypeInfo::GetName() const
 205 {
 206   return mTypeName;
 207 }
 208
 209 const std::string& TypeInfo::GetBaseName() const
 210 {
 211   return mBaseTypeName;
 212 }
 213
 214 Dali::TypeInfo::CreateFunction TypeInfo::GetCreator() const
 215 {
 216   return mCreate;
 217 }
 218
 219 size_t TypeInfo::GetActionCount() const
 220 {
 221   size_t count = mActions.size();
 222
 223   Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 224   while( base )
 225   {
 226     count += GetImplementation(base).mActions.size();
 227     base = Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 228   }
 229
 230   return count;
 231 }
 232
 233 std::string TypeInfo::GetActionName(size_t index) const
 234 {
 235   std::string name;
 236
 237   if( index < mActions.size() )
 238   {
 239     name = mActions[index].first;
 240   }
 241   else
 242   {
 243     size_t count = mActions.size();
 244
 245     Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 246     while( base )
 247     {
 248       size_t baseCount = GetImplementation(base).mActions.size();
 249
 250       if( index < count + baseCount )
 251       {
 252         name = GetImplementation(base).mActions[ index - count ].first;
 253         break;
 254       }
 255
 256       count += baseCount;
 257
 258       base = Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 259     }
 260   }
 261
 262   return name;
 263 }
 264
 265 size_t TypeInfo::GetSignalCount() const
 266 {
 267   size_t count = mSignalConnectors.size();
 268
 269   Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 270   while( base )
 271   {
 272     count += GetImplementation(base).mSignalConnectors.size();
 273     base = Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 274   }
 275
 276   return count;
 277 }
 278
 279 std::string TypeInfo::GetSignalName(size_t index) const
 280 {
 281   std::string name;
 282
 283   if( index < mSignalConnectors.size() )
 284   {
 285     name = mSignalConnectors[index].first;
 286   }
 287   else
 288   {
 289     size_t count = mSignalConnectors.size();
 290
 291     Dali::TypeInfo base = Dali::TypeRegistry::Get().GetTypeInfo( mBaseTypeName );
 292     while( base )
 293     {
 294       size_t baseCount = GetImplementation(base).mSignalConnectors.size();
 295
 296       if( index < count + baseCount )
 297       {
 298         name = GetImplementation(base).mSignalConnectors[ index - count ].first;
 299         break;
 300       }
 301
 302       count += baseCount;
 303
 304       base = Dali::TypeRegistry::Get().GetTypeInfo( base.GetBaseName() );
 305     }
 306   }
 307
 308   return name;
 309 }
 310
 311 void TypeInfo::GetPropertyIndices( Property::IndexContainer& indices ) const
 312 {
 313   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 314   if ( base )
 315   {
 316     const TypeInfo& baseImpl( GetImplementation( base ) );
 317     baseImpl.GetPropertyIndices( indices );
 318   }
 319
 320   if ( ! mRegisteredProperties.empty() )
 321   {
 322     indices.Reserve( indices.Size() + mRegisteredProperties.size() );
 323
 324     const RegisteredPropertyContainer::const_iterator endIter = mRegisteredProperties.end();
 325     for ( RegisteredPropertyContainer::const_iterator iter = mRegisteredProperties.begin(); iter != endIter; ++iter )
 326     {
 327       indices.PushBack( iter->first );
 328     }
 329   }
 330 }
 331
 332 const std::string& TypeInfo::GetPropertyName( Property::Index index ) const
 333 {
 334   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 335                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 336
 337   if ( iter != mRegisteredProperties.end() )
 338   {
 339     return iter->second.name;
 340   }
 341
 342   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 343   if ( base )
 344   {
 345     return GetImplementation(base).GetPropertyName( index );
 346   }
 347
 348   DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 349 }
 350
 351 void TypeInfo::AddActionFunction( const std::string &actionName, Dali::TypeInfo::ActionFunction function )
 352 {
 353   if( NULL == function)
 354   {
 355     DALI_LOG_WARNING("Action function is empty\n");
 356   }
 357   else
 358   {
 359     ActionContainer::iterator iter = std::find_if(mActions.begin(), mActions.end(),
 360                                                   PairFinder<std::string, ActionPair>(actionName));
 361
 362     if( iter == mActions.end() )
 363     {
 364       mActions.push_back( ActionPair( actionName, function ) );
 365     }
 366     else
 367     {
 368       DALI_LOG_WARNING("Action already exists in TypeRegistry Type\n", actionName.c_str());
 369     }
 370   }
 371 }
 372
 373 void TypeInfo::AddConnectorFunction( const std::string& signalName, Dali::TypeInfo::SignalConnectorFunction function )
 374 {
 375   if( NULL == function)
 376   {
 377     DALI_LOG_WARNING("Connector function is empty\n");
 378   }
 379   else
 380   {
 381     ConnectorContainer::iterator iter = find_if( mSignalConnectors.begin(), mSignalConnectors.end(),
 382                                                    PairFinder<std::string, ConnectionPair>(signalName) );
 383
 384     if( iter == mSignalConnectors.end() )
 385     {
 386       mSignalConnectors.push_back( ConnectionPair( signalName, function ) );
 387     }
 388     else
 389     {
 390       DALI_LOG_WARNING("Signal name already exists in TypeRegistry Type for signal connector function\n", signalName.c_str());
 391     }
 392   }
 393 }
 394
 395 void TypeInfo::AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc )
 396 {
 397   // The setter can be empty as a property can be read-only.
 398
 399   if ( NULL == getFunc )
 400   {
 401     DALI_ASSERT_ALWAYS( ! "GetProperty Function is empty" );
 402   }
 403   else
 404   {
 405     RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 406                                                           PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 407
 408     if ( iter == mRegisteredProperties.end() )
 409     {
 410       mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, setFunc, getFunc, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
 411     }
 412     else
 413     {
 414       DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 415     }
 416   }
 417 }
 418
 419 void TypeInfo::AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc)
 420 {
 421
 422   // The setter can be empty as a property can be read-only.
 423
 424   if ( NULL == getFunc )
 425   {
 426     DALI_ASSERT_ALWAYS( ! "GetProperty Function is empty" );
 427   }
 428   else
 429   {
 430     RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 431                                                           PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 432
 433     if ( iter == mRegisteredProperties.end() )
 434     {
 435       mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, setFunc, getFunc, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
 436     }
 437     else
 438     {
 439       DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 440     }
 441   }
 442
 443 }
 444
 445
 446 void TypeInfo::AddAnimatableProperty( const std::string& name, Property::Index index, Property::Type type )
 447 {
 448   RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 449                                                         PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 450
 451   if ( iter == mRegisteredProperties.end() )
 452   {
 453     mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
 454   }
 455   else
 456   {
 457     DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 458   }
 459 }
 460
 461 void TypeInfo::AddAnimatableProperty( const std::string& name, Property::Index index, const Property::Value& defaultValue )
 462 {
 463   RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 464                                                         PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 465
 466   if ( iter == mRegisteredProperties.end() )
 467   {
 468     mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( defaultValue.GetType(), name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
 469     mPropertyDefaultValues.push_back( PropertyDefaultValuePair( index, defaultValue ) );
 470   }
 471   else
 472   {
 473     DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 474   }
 475 }
 476
 477 void TypeInfo::AddAnimatablePropertyComponent( const std::string& name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex )
 478 {
 479   Property::Type type = GetPropertyType( baseIndex );
 480   DALI_ASSERT_ALWAYS( ( type == Property::VECTOR2 || type == Property::VECTOR3 || type == Property::VECTOR4 ) && "Base property does not support component" );
 481
 482   bool success = false;
 483
 484   RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 485                                                         PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 486
 487   if ( iter == mRegisteredProperties.end() )
 488   {
 489     iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 490                     PropertyComponentFinder< RegisteredPropertyPair >( baseIndex, componentIndex ) );
 491
 492     if ( iter == mRegisteredProperties.end() )
 493     {
 494       mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, name, baseIndex, componentIndex ) ) );
 495       success = true;
 496     }
 497   }
 498
 499   DALI_ASSERT_ALWAYS( success && "Property component already registered" );
 500 }
 501
 502 void TypeInfo::AddChildProperty( const std::string& name, Property::Index index, Property::Type type )
 503 {
 504   RegisteredPropertyContainer::iterator iter = find_if( mRegisteredChildProperties.begin(), mRegisteredChildProperties.end(),
 505                                                         PairFinder< Property::Index, RegisteredPropertyPair>(index) );
 506
 507   if ( iter == mRegisteredChildProperties.end() )
 508   {
 509     mRegisteredChildProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
 510   }
 511   else
 512   {
 513     DALI_ASSERT_ALWAYS( ! "Property index already added to Type" );
 514   }
 515 }
 516
 517 size_t TypeInfo::GetPropertyCount() const
 518 {
 519   size_t count( mRegisteredProperties.size() );
 520
 521   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 522   while ( base )
 523   {
 524     const TypeInfo& baseImpl( GetImplementation(base) );
 525     count += baseImpl.mRegisteredProperties.size();
 526     base = TypeRegistry::Get()->GetTypeInfo( baseImpl.mBaseTypeName );
 527   }
 528
 529   return count;
 530 }
 531
 532 Property::Index TypeInfo::GetPropertyIndex( const std::string& name ) const
 533 {
 534   Property::Index index = Property::INVALID_INDEX;
 535
 536   // Slow but should not be done that often
 537   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 538                                                           PropertyNameFinder< RegisteredPropertyPair >( name ) );
 539
 540   if ( iter != mRegisteredProperties.end() )
 541   {
 542     index = iter->first;
 543   }
 544   else
 545   {
 546     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 547     if ( base )
 548     {
 549       index = GetImplementation(base).GetPropertyIndex( name );
 550     }
 551   }
 552
 553   return index;
 554 }
 555
 556 Property::Index TypeInfo::GetBasePropertyIndex( Property::Index index ) const
 557 {
 558   Property::Index basePropertyIndex = Property::INVALID_INDEX;
 559
 560   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 561                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 562
 563   if ( iter != mRegisteredProperties.end() )
 564   {
 565     basePropertyIndex = iter->second.basePropertyIndex;
 566   }
 567   else
 568   {
 569     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 570     if ( base )
 571     {
 572       basePropertyIndex = GetImplementation(base).GetBasePropertyIndex( index );
 573     }
 574   }
 575
 576   return basePropertyIndex;
 577 }
 578
 579 int TypeInfo::GetComponentIndex( Property::Index index ) const
 580 {
 581   int componentIndex = Property::INVALID_COMPONENT_INDEX;
 582
 583   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 584                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 585
 586   if ( iter != mRegisteredProperties.end() )
 587   {
 588     componentIndex = iter->second.componentIndex;
 589   }
 590   else
 591   {
 592     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 593     if ( base )
 594     {
 595       componentIndex = GetImplementation(base).GetComponentIndex( index );
 596     }
 597   }
 598
 599   return componentIndex;
 600 }
 601
 602 Property::Index TypeInfo::GetChildPropertyIndex( const std::string& name ) const
 603 {
 604   Property::Index index = Property::INVALID_INDEX;
 605
 606   // Slow but should not be done that often
 607   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredChildProperties.begin(), mRegisteredChildProperties.end(),
 608                                                           PropertyNameFinder< RegisteredPropertyPair >( name ) );
 609
 610   if ( iter != mRegisteredChildProperties.end() )
 611   {
 612     index = iter->first;
 613   }
 614   else
 615   {
 616     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 617     if ( base )
 618     {
 619       index = GetImplementation(base).GetChildPropertyIndex( name );
 620     }
 621   }
 622
 623   return index;
 624 }
 625
 626 const std::string& TypeInfo::GetChildPropertyName( Property::Index index ) const
 627 {
 628   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredChildProperties.begin(), mRegisteredChildProperties.end(),
 629                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 630
 631   if ( iter != mRegisteredChildProperties.end() )
 632   {
 633     return iter->second.name;
 634   }
 635
 636   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 637   if ( base )
 638   {
 639     return GetImplementation(base).GetChildPropertyName( index );
 640   }
 641
 642   DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 643 }
 644
 645 Property::Type TypeInfo::GetChildPropertyType( Property::Index index ) const
 646 {
 647   Property::Type type( Property::NONE );
 648
 649   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredChildProperties.begin(), mRegisteredChildProperties.end(),
 650                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 651
 652   if ( iter != mRegisteredChildProperties.end() )
 653   {
 654     type = iter->second.type;
 655   }
 656   else
 657   {
 658     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 659     if ( base )
 660     {
 661       type = GetImplementation(base).GetChildPropertyType( index );
 662     }
 663     else
 664     {
 665       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 666     }
 667   }
 668
 669   return type;
 670 }
 671
 672 bool TypeInfo::IsPropertyWritable( Property::Index index ) const
 673 {
 674   bool writable( false );
 675
 676   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 677                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 678
 679   if ( iter != mRegisteredProperties.end() )
 680   {
 681     if( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) )
 682     {
 683       writable = true; // animatable property is writable
 684     }
 685     else
 686     {
 687       writable = iter->second.setFunc ? true : false;
 688     }
 689   }
 690   else
 691   {
 692     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 693     if ( base )
 694     {
 695       writable = GetImplementation(base).IsPropertyWritable( index );
 696     }
 697     else
 698     {
 699       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 700     }
 701   }
 702
 703   return writable;
 704 }
 705
 706 Property::Type TypeInfo::GetPropertyType( Property::Index index ) const
 707 {
 708   Property::Type type( Property::NONE );
 709
 710   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 711                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 712
 713   if ( iter != mRegisteredProperties.end() )
 714   {
 715     type = iter->second.type;
 716   }
 717   else
 718   {
 719     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 720     if ( base )
 721     {
 722       type = GetImplementation(base).GetPropertyType( index );
 723     }
 724     else
 725     {
 726       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 727     }
 728   }
 729
 730   return type;
 731 }
 732
 733 Property::Value TypeInfo::GetPropertyDefaultValue( Property::Index index ) const
 734 {
 735   PropertyDefaultValueContainer::const_iterator iter = find_if( mPropertyDefaultValues.begin(), mPropertyDefaultValues.end(),
 736                                                     PairFinder< Property::Index, PropertyDefaultValuePair >( index ) );
 737   if( iter !=  mPropertyDefaultValues.end() )
 738   {
 739     return iter->second;
 740   }
 741   else
 742   {
 743     return Property::Value( GetPropertyType( index ) );
 744   }
 745 }
 746
 747 void TypeInfo::SetProperty( BaseObject *object, Property::Index index, const Property::Value& value ) const
 748 {
 749   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 750                                                               PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 751   if ( iter != mRegisteredProperties.end() )
 752   {
 753     if( iter->second.setFunc )
 754     {
 755       if( mCSharpType )
 756       {
 757         // CSharp wants a property name not an index
 758         const std::string& name = (iter->second).name;
 759
 760         iter->second.cSharpSetFunc( object,name.c_str(), const_cast< Property::Value* >(&value) );
 761       }
 762       else
 763       {
 764         iter->second.setFunc( object, index, value );
 765       }
 766     }
 767   }
 768   else
 769   {
 770     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 771     if ( base )
 772     {
 773       GetImplementation(base).SetProperty( object, index, value );
 774     }
 775     else
 776     {
 777       DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 778     }
 779   }
 780 }
 781
 782 void TypeInfo::SetProperty( BaseObject *object, const std::string& name, const Property::Value& value ) const
 783 {
 784   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 785                                                               PropertyNameFinder< RegisteredPropertyPair >( name ) );
 786   if ( iter != mRegisteredProperties.end() )
 787   {
 788     DALI_ASSERT_ALWAYS( iter->second.setFunc && "Trying to write to a read-only property" );
 789
 790     if( mCSharpType )
 791     {
 792       // CSharp wants a property name not an index
 793       iter->second.cSharpSetFunc( object,name.c_str(), const_cast< Property::Value* >(&value ));
 794     }
 795     else
 796     {
 797       iter->second.setFunc( object, iter->first, value );
 798     }
 799   }
 800   else
 801   {
 802     Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 803     if ( base )
 804     {
 805       GetImplementation(base).SetProperty( object, name, value );
 806     }
 807     else
 808     {
 809       DALI_ASSERT_ALWAYS( ! "Cannot find property name" );
 810     }
 811   }
 812 }
 813
 814 Property::Value TypeInfo::GetProperty( const BaseObject *object, Property::Index index ) const
 815 {
 816   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 817                                                           PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
 818   if( iter != mRegisteredProperties.end() )
 819   {
 820     if( mCSharpType ) // using csharp property get which returns a pointer to a Property::Value
 821     {
 822       // CSharp wants a property name not an index
 823       // CSharp callback can't return an object by value, it can only return a pointer
 824       // CSharp has ownership of the pointer contents, which is fine because we are returning by from this function by value
 825       const std::string& name = (iter->second).name;
 826
 827       return *( iter->second.cSharpGetFunc( const_cast< BaseObject* >( object ), name.c_str()) );
 828
 829     }
 830     else
 831     {
 832       // Need to remove the constness here as CustomActor will not be able to call Downcast with a const pointer to the object
 833       return iter->second.getFunc( const_cast< BaseObject* >( object ), index );
 834     }
 835   }
 836
 837   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 838   if ( base )
 839   {
 840     return GetImplementation( base ).GetProperty( object, index );
 841   }
 842
 843   DALI_ASSERT_ALWAYS( ! "Cannot find property index" ); // use the same assert as Object
 844 }
 845
 846 Property::Value TypeInfo::GetProperty( const BaseObject *object, const std::string& name ) const
 847 {
 848   RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
 849                                                             PropertyNameFinder< RegisteredPropertyPair >( name ) );
 850
 851
 852
 853   if( iter != mRegisteredProperties.end() )
 854   {
 855     if( mCSharpType ) // using csharp property get which returns a pointer to a Property::Value
 856     {
 857        // CSharp wants a property name not an index
 858        // CSharp callback can't return an object by value, it can only return a pointer
 859        // CSharp has ownership of the pointer contents, which is fine because we are returning by from this function by value
 860        return *( iter->second.cSharpGetFunc( const_cast< BaseObject* >( object ), name.c_str() ));
 861
 862     }
 863     else
 864     {
 865       // Need to remove the constness here as CustomActor will not be able to call Downcast with a const pointer to the object
 866       return iter->second.getFunc( const_cast< BaseObject* >( object ), iter->first );
 867     }
 868   }
 869
 870   Dali::TypeInfo base = TypeRegistry::Get()->GetTypeInfo( mBaseTypeName );
 871   if ( base )
 872   {
 873     return GetImplementation( base ).GetProperty( object, name );
 874   }
 875
 876   DALI_ASSERT_ALWAYS( ! "Cannot find property name" );
 877 }
 878
 879 } // namespace Internal
 880
 881 } // namespace Dali