dali-toolkit/internal/builder/builder-impl.cpp

   1 /*
   2  * Copyright (c) 2020 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-toolkit/internal/builder/builder-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <sys/stat.h>
  23 #include <sstream>
  24
  25 #include <dali/public-api/actors/camera-actor.h>
  26 #include <dali/public-api/actors/layer.h>
  27 #include <dali/public-api/object/property-array.h>
  28 #include <dali/public-api/object/type-info.h>
  29 #include <dali/public-api/object/type-registry.h>
  30 #include <dali/public-api/render-tasks/render-task-list.h>
  31 #include <dali/public-api/signals/functor-delegate.h>
  32 #include <dali/devel-api/common/stage.h>
  33 #include <dali/devel-api/scripting/scripting.h>
  34 #include <dali/integration-api/debug.h>
  35 #include <dali-toolkit/devel-api/controls/control-devel.h>
  36
  37 // INTERNAL INCLUDES
  38 #include <dali-toolkit/public-api/controls/control.h>
  39 #include <dali-toolkit/devel-api/asset-manager/asset-manager.h>
  40 #include <dali-toolkit/devel-api/builder/json-parser.h>
  41
  42 #include <dali-toolkit/internal/builder/builder-declarations.h>
  43 #include <dali-toolkit/internal/builder/builder-filesystem.h>
  44 #include <dali-toolkit/internal/builder/builder-get-is.inl.h>
  45 #include <dali-toolkit/internal/builder/builder-impl-debug.h>
  46 #include <dali-toolkit/internal/builder/builder-set-property.h>
  47 #include <dali-toolkit/internal/builder/replacement.h>
  48 #include <dali-toolkit/internal/builder/tree-node-manipulator.h>
  49
  50 namespace Dali
  51 {
  52
  53 namespace Toolkit
  54 {
  55
  56 namespace Internal
  57 {
  58 class Replacement;
  59
  60 extern Animation CreateAnimation(const TreeNode& child, const Replacement& replacements, const Dali::Actor searchRoot, Builder* const builder );
  61
  62 extern Actor SetupSignalAction(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder);
  63
  64 extern Actor SetupPropertyNotification(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder);
  65
  66
  67 #if defined(DEBUG_ENABLED)
  68 Integration::Log::Filter* gFilterScript  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_SCRIPT");
  69 #endif
  70
  71 namespace
  72 {
  73
  74 #define TOKEN_STRING(x) #x
  75
  76 const std::string KEYNAME_ACTORS           = "actors";
  77 const std::string KEYNAME_ENTRY_TRANSITION = "entryTransition";
  78 const std::string KEYNAME_EXIT_TRANSITION  = "exitTransition";
  79 const std::string KEYNAME_INCLUDES         = "includes";
  80 const std::string KEYNAME_INHERIT          = "inherit";
  81 const std::string KEYNAME_MAPPINGS         = "mappings";
  82 const std::string KEYNAME_NAME             = "name";
  83 const std::string KEYNAME_SIGNALS          = "signals";
  84 const std::string KEYNAME_STATES           = "states";
  85 const std::string KEYNAME_STYLES           = "styles";
  86 const std::string KEYNAME_TEMPLATES        = "templates";
  87 const std::string KEYNAME_TRANSITIONS      = "transitions";
  88 const std::string KEYNAME_TYPE             = "type";
  89 const std::string KEYNAME_VISUALS          = "visuals";
  90
  91 const std::string PROPERTIES = "properties";
  92 const std::string ANIMATABLE_PROPERTIES = "animatableProperties";
  93
  94 typedef std::vector<const TreeNode*> TreeNodeList;
  95
  96
  97 bool GetMappingKey( const std::string& str, std::string& key )
  98 {
  99   bool result = false;
 100   std::string test( str );
 101   if( ! test.empty() )
 102   {
 103     if( test.at(0) == '<' )
 104     {
 105       if( test.at(test.length()-1) == '>' )
 106       {
 107         key = test.substr( 1, test.length()-2 );
 108         result = true;
 109       }
 110     }
 111   }
 112   return result;
 113 }
 114
 115 /*
 116  * Recursively collects all styles in a node (An array of style names).
 117  *
 118  * stylesCollection The set of styles from the json file (a json object of named styles)
 119  * style The style array to begin the collection from
 120  * styleList The style list to add nodes to apply
 121  */
 122 void CollectAllStyles( const TreeNode& stylesCollection, const TreeNode& style, TreeNodeList& styleList )
 123 {
 124   // style is an array of style names
 125   if( TreeNode::ARRAY == style.GetType() )
 126   {
 127     for(TreeNode::ConstIterator iter = style.CBegin(); iter != style.CEnd(); ++iter)
 128     {
 129       if( OptionalString styleName = IsString( (*iter).second ) )
 130       {
 131         if( OptionalChild node = IsChildIgnoreCase( stylesCollection, *styleName) )
 132         {
 133           styleList.push_back( &(*node) );
 134
 135           OptionalChild subStyle = IsChild( *node, KEYNAME_INHERIT );
 136           if( ! subStyle )
 137           {
 138             subStyle = IsChild( *node, KEYNAME_STYLES );
 139           }
 140           if( subStyle )
 141           {
 142             CollectAllStyles( stylesCollection, *subStyle, styleList );
 143           }
 144         }
 145       }
 146     }
 147   }
 148 }
 149
 150
 151 } // namespace anon
 152
 153
 154 Builder::Builder()
 155 : mSlotDelegate( this )
 156 {
 157   mParser = Dali::Toolkit::JsonParser::New();
 158
 159   Property::Map defaultDirs;
 160   defaultDirs[TOKEN_STRING(DALI_IMAGE_DIR)]       = AssetManager::GetDaliImagePath();
 161   defaultDirs[TOKEN_STRING(DALI_SOUND_DIR)]       = AssetManager::GetDaliSoundPath();
 162   defaultDirs[TOKEN_STRING(DALI_STYLE_DIR)]       = AssetManager::GetDaliStylePath();
 163   defaultDirs[TOKEN_STRING(DALI_STYLE_IMAGE_DIR)] = AssetManager::GetDaliStyleImagePath();
 164
 165   AddConstants( defaultDirs );
 166 }
 167
 168 void Builder::LoadFromString( std::string const& data, Dali::Toolkit::Builder::UIFormat format )
 169 {
 170   // parser to get constants and includes only
 171   Dali::Toolkit::JsonParser parser = Dali::Toolkit::JsonParser::New();
 172
 173   if( !parser.Parse( data ) )
 174   {
 175     DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
 176                       parser.GetErrorLineNumber(),
 177                       parser.GetErrorColumn(),
 178                       parser.GetErrorDescription().c_str() );
 179
 180     DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
 181   }
 182   else
 183   {
 184     // load constant map (allows the user to override the constants in the json after loading)
 185     LoadConstants( *parser.GetRoot(), mReplacementMap );
 186     // load configuration map
 187     LoadConfiguration( *parser.GetRoot(), mConfigurationMap );
 188     // merge includes
 189     if( OptionalChild includes = IsChild(*parser.GetRoot(), KEYNAME_INCLUDES) )
 190     {
 191       Replacement replacer( mReplacementMap );
 192
 193       for(TreeNode::ConstIterator iter = (*includes).CBegin(); iter != (*includes).CEnd(); ++iter)
 194       {
 195         OptionalString filename = replacer.IsString( (*iter).second );
 196
 197         if( filename )
 198         {
 199 #if defined(DEBUG_ENABLED)
 200           DALI_SCRIPT_VERBOSE("Loading Include '%s'\n", (*filename).c_str());
 201 #endif
 202           LoadFromString( GetFileContents(*filename) );
 203         }
 204       }
 205     }
 206
 207     if( mParser.Parse( data ) )
 208     {
 209       // Drop the styles and get them to be rebuilt against the new parse tree as required.
 210       mStyles.Clear();
 211     }
 212     else
 213     {
 214       DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
 215                         mParser.GetErrorLineNumber(),
 216                         mParser.GetErrorColumn(),
 217                         mParser.GetErrorDescription().c_str() );
 218
 219       DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
 220     }
 221   }
 222
 223   DUMP_PARSE_TREE(mParser); // This macro only writes out if DEBUG is enabled and the "DUMP_TREE" constant is defined in the stylesheet.
 224   DUMP_TEST_MAPPINGS(mParser);
 225
 226   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Cannot parse JSON");
 227 }
 228
 229 void Builder::AddConstants( const Property::Map& map )
 230 {
 231   mReplacementMap.Merge( map );
 232 }
 233
 234 void Builder::AddConstant( const std::string& key, const Property::Value& value )
 235 {
 236   mReplacementMap[key] = value;
 237 }
 238
 239 const Property::Map& Builder::GetConfigurations() const
 240 {
 241   return mConfigurationMap;
 242 }
 243
 244 const Property::Map& Builder::GetConstants() const
 245 {
 246   return mReplacementMap;
 247 }
 248
 249 const Property::Value& Builder::GetConstant( const std::string& key ) const
 250 {
 251   Property::Value* match = mReplacementMap.Find( key );
 252   if( match )
 253   {
 254     return (*match);
 255   }
 256   else
 257   {
 258     static Property::Value invalid;
 259     return invalid;
 260   }
 261 }
 262
 263 Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor )
 264 {
 265   Replacement replacement(map, mReplacementMap);
 266   return CreateAnimation( animationName, replacement, sourceActor);
 267 }
 268
 269 Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map )
 270 {
 271   Replacement replacement(map, mReplacementMap);
 272   return CreateAnimation( animationName, replacement, Stage::GetCurrent().GetRootLayer() );
 273 }
 274
 275 Animation Builder::CreateAnimation( const std::string& animationName, Dali::Actor sourceActor )
 276 {
 277   Replacement replacement( mReplacementMap );
 278
 279   return CreateAnimation( animationName, replacement, sourceActor );
 280 }
 281
 282 Animation Builder::CreateAnimation( const std::string& animationName )
 283 {
 284   Replacement replacement( mReplacementMap );
 285
 286   return CreateAnimation( animationName, replacement, Dali::Stage::GetCurrent().GetRootLayer() );
 287 }
 288
 289 BaseHandle Builder::Create( const std::string& templateName )
 290 {
 291   Replacement replacement( mReplacementMap );
 292   return Create( templateName, replacement );
 293 }
 294
 295 BaseHandle Builder::Create( const std::string& templateName, const Property::Map& map )
 296 {
 297   Replacement replacement( map, mReplacementMap );
 298   return Create( templateName, replacement );
 299 }
 300
 301 BaseHandle Builder::CreateFromJson( const std::string& json )
 302 {
 303   BaseHandle ret;
 304
 305   // merge in new template, hoping no one else has one named '@temp@'
 306   std::string newTemplate =
 307     std::string("{\"templates\":{\"@temp@\":") +                      \
 308     json +                                                            \
 309     std::string("}}");
 310
 311   if( mParser.Parse(newTemplate) )
 312   {
 313     Replacement replacement( mReplacementMap );
 314     ret = Create( "@temp@", replacement );
 315   }
 316
 317   return ret;
 318 }
 319
 320 bool Builder::ApplyFromJson(  Handle& handle, const std::string& json )
 321 {
 322   bool ret = false;
 323
 324   // merge new style, hoping no one else has one named '@temp@'
 325   std::string newStyle =
 326     std::string("{\"styles\":{\"@temp@\":") +                           \
 327     json +                                                              \
 328     std::string("}}");
 329
 330   if( mParser.Parse(newStyle) )
 331   {
 332     Replacement replacement( mReplacementMap );
 333     ret = ApplyStyle( "@temp@", handle, replacement );
 334   }
 335
 336   return ret;
 337 }
 338
 339 bool Builder::ApplyStyle( const std::string& styleName, Handle& handle )
 340 {
 341   Replacement replacer( mReplacementMap );
 342   return ApplyStyle( styleName, handle, replacer );
 343 }
 344
 345 bool Builder::LookupStyleName( const std::string& styleName )
 346 {
 347   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 348
 349   OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
 350   OptionalChild style  = IsChildIgnoreCase( *styles, styleName );
 351
 352   if( styles && style )
 353   {
 354     return true;
 355   }
 356   return false;
 357 }
 358
 359 const StylePtr Builder::GetStyle( const std::string& styleName )
 360 {
 361   const StylePtr* style = mStyles.FindConst( styleName );
 362
 363   if( style==NULL )
 364   {
 365     return StylePtr(NULL);
 366   }
 367   else
 368   {
 369     return *style;
 370   }
 371 }
 372
 373 void Builder::AddActors( Actor toActor )
 374 {
 375   // 'stage' is the default/by convention section to add from
 376   AddActors( "stage", toActor );
 377 }
 378
 379 void Builder::AddActors( const std::string &sectionName, Actor toActor )
 380 {
 381   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 382
 383   Property::Map overrideMap;
 384   Replacement replacements(overrideMap, mReplacementMap);
 385
 386   OptionalChild add = IsChild(*mParser.GetRoot(), sectionName);
 387
 388   if( add )
 389   {
 390     for( TreeNode::ConstIterator iter = (*add).CBegin(); iter != (*add).CEnd(); ++iter )
 391     {
 392       // empty actor adds directly to the stage
 393       BaseHandle baseHandle = DoCreate( *mParser.GetRoot(), (*iter).second, Actor(), replacements );
 394       Actor actor = Actor::DownCast(baseHandle);
 395       if(actor)
 396       {
 397         toActor.Add( actor );
 398       }
 399     }
 400
 401     // if were adding the 'stage' section then also check for a render task called stage
 402     // to add automatically
 403     if( "stage" == sectionName )
 404     {
 405       if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "renderTasks") )
 406       {
 407         if( OptionalChild tasks = IsChild(*renderTasks, "stage") )
 408         {
 409           CreateRenderTask( "stage" );
 410         }
 411       }
 412     }
 413   }
 414 }
 415
 416 void Builder::CreateRenderTask( const std::string &name )
 417 {
 418   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 419
 420   Replacement constant(mReplacementMap);
 421
 422   const Stage& stage = Stage::GetCurrent();
 423
 424   OptionalChild tasks = IsChild(*mParser.GetRoot(), "renderTasks");
 425
 426   if(tasks)
 427   {
 428     //
 429     // Create the tasks from the current task as generally we want
 430     // to setup task zero and onwards. Although this does overwrite
 431     // the properties of the current task.
 432     //
 433     if( OptionalChild renderTask = IsChild(*tasks, name ) )
 434     {
 435       RenderTaskList list = stage.GetRenderTaskList();
 436       unsigned int start = list.GetTaskCount();
 437
 438       RenderTask task;
 439       if(0 == start)
 440       {
 441         // zero should have already been created by the stage so really
 442         // this case should never happen
 443         task = list.CreateTask();
 444         start++;
 445       }
 446
 447       TreeNode::ConstIterator iter = (*renderTask).CBegin();
 448       task = list.GetTask( start - 1 );
 449
 450       SetupTask( task, (*iter).second, constant  );
 451
 452       ++iter;
 453
 454       for(; iter != (*renderTask).CEnd(); ++iter )
 455       {
 456         task = list.CreateTask();
 457         SetupTask( task, (*iter).second, constant );
 458       }
 459     }
 460   }
 461 }
 462
 463 Path Builder::GetPath( const std::string& name )
 464 {
 465   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 466
 467   Path ret;
 468
 469   PathLut::const_iterator iter( mPathLut.find( name ) );
 470   if( iter != mPathLut.end() )
 471   {
 472     ret = iter->second;
 473   }
 474   else
 475   {
 476     if( OptionalChild paths = IsChild( *mParser.GetRoot(), "paths") )
 477     {
 478       if( OptionalChild path = IsChild( *paths, name ) )
 479       {
 480         //points property
 481         if( OptionalChild pointsProperty = IsChild( *path, "points") )
 482         {
 483           Dali::Property::Value points(Property::ARRAY);
 484           if( DeterminePropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 485           {
 486             ret = Path::New();
 487             ret.SetProperty( Path::Property::POINTS, points);
 488
 489             //controlPoints property
 490             if( OptionalChild pointsProperty = IsChild( *path, "controlPoints") )
 491             {
 492               Dali::Property::Value points(Property::ARRAY);
 493               if( DeterminePropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 494               {
 495                 ret.SetProperty( Path::Property::CONTROL_POINTS, points);
 496               }
 497             }
 498             else
 499             {
 500               //Curvature
 501               float curvature(0.25f);
 502               if( OptionalFloat pointsProperty = IsFloat( *path, "curvature") )
 503               {
 504                 curvature = *pointsProperty;
 505               }
 506               ret.GenerateControlPoints(curvature);
 507             }
 508
 509             //Add the new path to the hash table for paths
 510             mPathLut[ name ] = ret;
 511           }
 512         }
 513         else
 514         {
 515           //Interpolation points not specified
 516           DALI_SCRIPT_WARNING("Interpolation points not specified for path '%s'\n", name.c_str() );
 517         }
 518       }
 519
 520     }
 521   }
 522
 523   return ret;
 524 }
 525
 526 PathConstrainer Builder::GetPathConstrainer( const std::string& name )
 527 {
 528   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 529
 530   //Search the pathConstrainer in the LUT
 531   size_t count( mPathConstrainerLut.size() );
 532   for( size_t i(0); i!=count; ++i )
 533   {
 534     if( mPathConstrainerLut[i].name == name )
 535     {
 536       //PathConstrainer has already been created
 537       return mPathConstrainerLut[i].pathConstrainer;
 538     }
 539   }
 540
 541   //Create a new PathConstrainer
 542   PathConstrainer ret;
 543   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 544   {
 545     if( OptionalChild pathConstrainer = IsChild( *constrainers, name ) )
 546     {
 547       OptionalString constrainerType(IsString(IsChild(*pathConstrainer, "type")));
 548       if(!constrainerType)
 549       {
 550         DALI_SCRIPT_WARNING("Constrainer type not specified for constrainer '%s'\n", name.c_str() );
 551       }
 552       else if( *constrainerType == "PathConstrainer")
 553       {
 554         //points property
 555         if( OptionalChild pointsProperty = IsChild( *pathConstrainer, "points") )
 556         {
 557           Dali::Property::Value points(Property::ARRAY);
 558           if( DeterminePropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 559           {
 560             ret = PathConstrainer::New();
 561             ret.SetProperty( PathConstrainer::Property::POINTS, points);
 562
 563             //controlPoints property
 564             if( OptionalChild pointsProperty = IsChild( *pathConstrainer, "controlPoints") )
 565             {
 566               Dali::Property::Value points(Property::ARRAY);
 567               if( DeterminePropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 568               {
 569                 ret.SetProperty( PathConstrainer::Property::CONTROL_POINTS, points);
 570               }
 571
 572               //Forward vector
 573               OptionalVector3 forward( IsVector3( IsChild(*pathConstrainer, "forward" ) ) );
 574               if( forward )
 575               {
 576                 ret.SetProperty( PathConstrainer::Property::FORWARD, *forward);
 577               }
 578
 579               //Add the new constrainer to the vector of PathConstrainer
 580               PathConstrainerEntry entry = {name,ret};
 581               mPathConstrainerLut.push_back( entry );
 582             }
 583             else
 584             {
 585               //Control points not specified
 586               DALI_SCRIPT_WARNING("Control points not specified for pathConstrainer '%s'\n", name.c_str() );
 587             }
 588           }
 589         }
 590         else
 591         {
 592           //Interpolation points not specified
 593           DALI_SCRIPT_WARNING("Interpolation points not specified for pathConstrainer '%s'\n", name.c_str() );
 594         }
 595       }
 596       else
 597       {
 598         DALI_SCRIPT_WARNING("Constrainer '%s' is not a PathConstrainer\n", name.c_str() );
 599       }
 600     }
 601   }
 602
 603   return ret;
 604 }
 605
 606
 607 bool Builder::IsPathConstrainer( const std::string& name )
 608 {
 609   size_t count( mPathConstrainerLut.size() );
 610   for( size_t i(0); i!=count; ++i )
 611   {
 612     if( mPathConstrainerLut[i].name == name )
 613     {
 614       return true;
 615     }
 616   }
 617
 618   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 619   {
 620     if( OptionalChild constrainer = IsChild( *constrainers, name ) )
 621     {
 622       OptionalString constrainerType(IsString(IsChild(*constrainer, "type")));
 623       if(!constrainerType)
 624       {
 625         return false;
 626       }
 627       else
 628       {
 629          return *constrainerType == "PathConstrainer";
 630       }
 631     }
 632   }
 633   return false;
 634 }
 635
 636 Dali::LinearConstrainer Builder::GetLinearConstrainer( const std::string& name )
 637 {
 638   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 639
 640   //Search the LinearConstrainer in the LUT
 641   size_t count( mLinearConstrainerLut.size() );
 642   for( size_t i(0); i!=count; ++i )
 643   {
 644     if( mLinearConstrainerLut[i].name == name )
 645     {
 646       //LinearConstrainer has already been created
 647       return mLinearConstrainerLut[i].linearConstrainer;
 648     }
 649   }
 650
 651   //Create a new LinearConstrainer
 652   LinearConstrainer ret;
 653   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 654   {
 655     if( OptionalChild linearConstrainer = IsChild( *constrainers, name ) )
 656     {
 657       OptionalString constrainerType(IsString(IsChild(*linearConstrainer, "type")));
 658       if(!constrainerType)
 659       {
 660         DALI_SCRIPT_WARNING("Constrainer type not specified for constrainer '%s'\n", name.c_str() );
 661       }
 662       else if( *constrainerType == "LinearConstrainer")
 663       {
 664         //points property
 665         if( OptionalChild pointsProperty = IsChild( *linearConstrainer, "value") )
 666         {
 667           Dali::Property::Value points(Property::ARRAY);
 668           if( DeterminePropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 669           {
 670             ret = Dali::LinearConstrainer::New();
 671             ret.SetProperty( LinearConstrainer::Property::VALUE, points);
 672
 673             //controlPoints property
 674             if( OptionalChild pointsProperty = IsChild( *linearConstrainer, "progress") )
 675             {
 676               Dali::Property::Value points(Property::ARRAY);
 677               if( DeterminePropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 678               {
 679                 ret.SetProperty( LinearConstrainer::Property::PROGRESS, points);
 680               }
 681             }
 682             //Add the new constrainer to vector of LinearConstrainer
 683             LinearConstrainerEntry entry = {name,ret};
 684             mLinearConstrainerLut.push_back( entry );
 685           }
 686         }
 687         else
 688         {
 689           //Interpolation points not specified
 690           DALI_SCRIPT_WARNING("Values not specified for LinearConstrainer '%s'\n", name.c_str() );
 691         }
 692       }
 693       else
 694       {
 695         DALI_SCRIPT_WARNING("Constrainer '%s' is not a LinearConstrainer\n", name.c_str() );
 696       }
 697     }
 698   }
 699
 700   return ret;
 701 }
 702
 703 bool Builder::IsLinearConstrainer( const std::string& name )
 704 {
 705   // Search the LinearConstrainer in the LUT
 706   size_t count( mLinearConstrainerLut.size() );
 707   for( size_t i(0); i!=count; ++i )
 708   {
 709     if( mLinearConstrainerLut[i].name == name )
 710     {
 711       return true;
 712     }
 713   }
 714
 715   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 716   {
 717     if( OptionalChild constrainer = IsChild( *constrainers, name ) )
 718     {
 719       OptionalString constrainerType(IsString(IsChild(*constrainer, "type")));
 720       if(!constrainerType)
 721       {
 722         return false;
 723       }
 724       else
 725       {
 726          return *constrainerType == "LinearConstrainer";
 727       }
 728     }
 729   }
 730   return false;
 731 }
 732
 733 Toolkit::Builder::BuilderSignalType& Builder::QuitSignal()
 734 {
 735   return mQuitSignal;
 736 }
 737
 738 void Builder::EmitQuitSignal()
 739 {
 740   mQuitSignal.Emit();
 741 }
 742
 743 Builder::~Builder()
 744 {
 745 }
 746
 747 void Builder::LoadConfiguration( const TreeNode& root, Property::Map& intoMap )
 748 {
 749   Replacement replacer(intoMap);
 750
 751   if( OptionalChild constants = IsChild(root, "config") )
 752   {
 753     for(TreeNode::ConstIterator iter = (*constants).CBegin();
 754         iter != (*constants).CEnd(); ++iter)
 755     {
 756       Dali::Property::Value property;
 757       if( (*iter).second.GetName() )
 758       {
 759         DeterminePropertyFromNode( (*iter).second, property, replacer );
 760
 761         // If config is string, find constant and replace it to original value.
 762         if( (*iter).second.GetType() == TreeNode::STRING )
 763         {
 764           std::string stringConfigValue;
 765           if( property.Get( stringConfigValue ) )
 766           {
 767             std::size_t pos = 0;
 768
 769             while( pos < stringConfigValue.size() )
 770             {
 771               // If we can't find "{","}" pair in stringConfigValue, will out loop.
 772               std::size_t leftPos = stringConfigValue.find( "{", pos );
 773               if( leftPos != std::string::npos )
 774               {
 775                 std::size_t rightPos = stringConfigValue.find( "}", pos+1 );
 776
 777                 if( rightPos != std::string::npos )
 778                 {
 779                   // If we find "{","}" pair but can't find matched constant
 780                   // try to find other "{","}" pair after current left position.
 781                   pos = leftPos+1;
 782
 783                   for( uint32_t i = 0; i < mReplacementMap.Count() ; i++ )
 784                   {
 785                     Property::Key constant = mReplacementMap.GetKeyAt(i);
 786
 787                     // Compare string which is between "{" and "}" with constant string
 788                     // If they are same, change string in stringConfigValue to mapped constant value.
 789                     if ( 0 == stringConfigValue.compare( leftPos+1, rightPos-leftPos-1, constant.stringKey ) )
 790                     {
 791                       std::string replaceString;
 792                       mReplacementMap.GetValue(i).Get( replaceString );
 793
 794                       stringConfigValue.replace( leftPos, rightPos-leftPos+1, replaceString );
 795                       pos = leftPos + replaceString.size();
 796                       break;
 797                     }
 798                   }
 799                 }
 800                 else
 801                 {
 802                   // If we cannot find constant in const value, will out loop.
 803                   pos = stringConfigValue.size();
 804                 }
 805               }
 806               else
 807               {
 808                 // If we cannot find constant in const value, will out loop.
 809                 pos = stringConfigValue.size();
 810               }
 811             }
 812             property = Property::Value( stringConfigValue );
 813           }
 814         }
 815         intoMap[ (*iter).second.GetName() ] = property;
 816       }
 817     }
 818   }
 819 }
 820
 821 void Builder::LoadConstants( const TreeNode& root, Property::Map& intoMap )
 822 {
 823   Replacement replacer(intoMap);
 824
 825   if( OptionalChild constants = IsChild(root, "constants") )
 826   {
 827     for(TreeNode::ConstIterator iter = (*constants).CBegin();
 828         iter != (*constants).CEnd(); ++iter)
 829     {
 830       Dali::Property::Value property;
 831       if( (*iter).second.GetName() )
 832       {
 833 #if defined(DEBUG_ENABLED)
 834         DALI_SCRIPT_VERBOSE("Constant set from json '%s'\n", (*iter).second.GetName());
 835 #endif
 836         DeterminePropertyFromNode( (*iter).second, property, replacer );
 837         intoMap[ (*iter).second.GetName() ] = property;
 838       }
 839     }
 840   }
 841
 842 #if defined(DEBUG_ENABLED)
 843   Property::Value* iter = intoMap.Find( "CONFIG_SCRIPT_LOG_LEVEL" );
 844   if( iter && iter->GetType() == Property::STRING )
 845   {
 846     std::string logLevel( iter->Get< std::string >() );
 847     if( logLevel == "NoLogging" )
 848     {
 849       gFilterScript->SetLogLevel( Integration::Log::NoLogging );
 850     }
 851     else if( logLevel == "Concise" )
 852     {
 853       gFilterScript->SetLogLevel( Integration::Log::Concise );
 854     }
 855     else if( logLevel == "General" )
 856     {
 857       gFilterScript->SetLogLevel( Integration::Log::General );
 858     }
 859     else if( logLevel == "Verbose" )
 860     {
 861       gFilterScript->SetLogLevel( Integration::Log::Verbose );
 862     }
 863   }
 864 #endif
 865 }
 866
 867 Animation Builder::CreateAnimation( const std::string& animationName, const Replacement& replacement, Dali::Actor sourceActor )
 868 {
 869   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 870
 871   Animation anim;
 872
 873   if( OptionalChild animations = IsChild(*mParser.GetRoot(), "animations") )
 874   {
 875     if( OptionalChild animation = IsChild(*animations, animationName) )
 876     {
 877       anim = Dali::Toolkit::Internal::CreateAnimation( *animation, replacement, sourceActor, this );
 878     }
 879     else
 880     {
 881       DALI_SCRIPT_WARNING( "Request for Animation called '%s' failed\n", animationName.c_str() );
 882     }
 883   }
 884   else
 885   {
 886     DALI_SCRIPT_WARNING( "Request for Animation called '%s' failed (no animation section)\n", animationName.c_str() );
 887   }
 888
 889   return anim;
 890 }
 891
 892 BaseHandle Builder::Create( const std::string& templateName, const Replacement& constant )
 893 {
 894   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 895
 896   BaseHandle baseHandle;
 897
 898   OptionalChild templates = IsChild(*mParser.GetRoot(), KEYNAME_TEMPLATES);
 899
 900   if( !templates )
 901   {
 902     DALI_SCRIPT_WARNING("No template section found to CreateFromTemplate\n");
 903   }
 904   else
 905   {
 906     OptionalChild childTemplate = IsChild(*templates, templateName);
 907     if(!childTemplate)
 908     {
 909       DALI_SCRIPT_WARNING("Template '%s' does not exist in template section\n", templateName.c_str());
 910     }
 911     else
 912     {
 913       OptionalString type = constant.IsString( IsChild(*childTemplate, KEYNAME_TYPE) );
 914
 915       if(!type)
 916       {
 917         DALI_SCRIPT_WARNING("Cannot create template '%s' as template section is missing 'type'\n", templateName.c_str());
 918       }
 919       else
 920       {
 921         baseHandle = DoCreate( *mParser.GetRoot(), *childTemplate, Actor(), constant );
 922       }
 923     }
 924   }
 925
 926   return baseHandle;
 927 }
 928
 929 /*
 930  * Create a dali type from a node.
 931  * If parent given and an actor type was created then add it to the parent and
 932  * recursively add nodes children.
 933  */
 934 BaseHandle Builder::DoCreate( const TreeNode& root, const TreeNode& node,
 935                               Actor parent, const Replacement& replacements )
 936 {
 937   BaseHandle baseHandle;
 938   TypeInfo typeInfo;
 939   const TreeNode* templateNode = NULL;
 940
 941   if( OptionalString typeName = IsString(node, KEYNAME_TYPE) )
 942   {
 943     typeInfo = TypeRegistry::Get().GetTypeInfo( *typeName );
 944
 945     if( !typeInfo )
 946     {
 947       // a template name is also allowed inplace of the type name
 948       OptionalChild templates = IsChild( root, KEYNAME_TEMPLATES);
 949
 950       if( templates )
 951       {
 952         if( OptionalChild isTemplate = IsChild( *templates, *typeName ) )
 953         {
 954           templateNode = &(*isTemplate);
 955
 956           if( OptionalString templateTypeName = IsString(*templateNode, KEYNAME_TYPE) )
 957           {
 958             typeInfo = TypeRegistry::Get().GetTypeInfo( *templateTypeName );
 959           }
 960         }
 961       }
 962     }
 963   }
 964
 965   if(!typeInfo)
 966   {
 967     DALI_SCRIPT_WARNING("Cannot create Dali type from node '%s'\n", node.GetName());
 968   }
 969   else
 970   {
 971     baseHandle       = typeInfo.CreateInstance();
 972     Handle handle    = Handle::DownCast(baseHandle);
 973     Actor actor      = Actor::DownCast(handle);
 974
 975     if(handle)
 976     {
 977
 978       DALI_SCRIPT_VERBOSE("Create:%s\n", typeInfo.GetName().c_str());
 979
 980 #if defined(DEBUG_ENABLED)
 981       if(handle)
 982       {
 983         DALI_SCRIPT_VERBOSE("  Is Handle Object=%d\n", (long*)handle.GetObjectPtr());
 984         DALI_SCRIPT_VERBOSE("  Is Handle Property Count=%d\n", handle.GetPropertyCount());
 985       }
 986
 987       if(actor)
 988       {
 989         DALI_SCRIPT_VERBOSE("  Is Actor id=%d\n", actor.GetProperty< int >( Actor::Property::ID ));
 990       }
 991
 992       Toolkit::Control control  = Toolkit::Control::DownCast(handle);
 993       if(control)
 994       {
 995         DALI_SCRIPT_VERBOSE("  Is Control id=%d\n", actor.GetProperty< int >( Actor::Property::ID ));
 996       }
 997 #endif // DEBUG_ENABLED
 998
 999       if( templateNode )
1000       {
1001         ApplyProperties( root, *templateNode, handle, replacements );
1002
1003         if( OptionalChild actors = IsChild( *templateNode, KEYNAME_ACTORS ) )
1004         {
1005           for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
1006           {
1007             DoCreate( root, (*iter).second, actor, replacements );
1008           }
1009         }
1010       }
1011
1012       if( actor )
1013       {
1014         // add children of all the styles
1015         if( OptionalChild actors = IsChild( node, KEYNAME_ACTORS ) )
1016         {
1017           for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
1018           {
1019             DoCreate( root, (*iter).second, actor, replacements );
1020           }
1021         }
1022
1023         // apply style on top as they need the children to exist
1024         ApplyAllStyleProperties( root, node, actor, replacements );
1025
1026         // then add to parent
1027         if( parent )
1028         {
1029           parent.Add( actor );
1030         }
1031       }
1032       else
1033       {
1034         ApplyProperties( root, node, handle, replacements );
1035       }
1036     }
1037     else
1038     {
1039       DALI_SCRIPT_WARNING("Cannot create handle from type '%s'\n", typeInfo.GetName().c_str());
1040     }
1041   }
1042
1043   return baseHandle;
1044 }
1045
1046 void Builder::SetupTask( RenderTask& task, const TreeNode& node, const Replacement& constant )
1047 {
1048   const Stage& stage = Stage::GetCurrent();
1049   Layer root  = stage.GetRootLayer();
1050
1051   if( OptionalString s = constant.IsString( IsChild(node, "sourceActor") ) )
1052   {
1053     Actor actor = root.FindChildByName(*s);
1054     if(actor)
1055     {
1056       task.SetSourceActor( actor );
1057     }
1058     else
1059     {
1060       DALI_SCRIPT_WARNING("Cannot find source actor on stage for render task called '%s'\n", (*s).c_str() );
1061     }
1062   }
1063
1064   if( OptionalString s = constant.IsString( IsChild(node, "cameraActor") ) )
1065   {
1066     CameraActor actor = CameraActor::DownCast( root.FindChildByName(*s) );
1067     if(actor)
1068     {
1069       task.SetCameraActor( actor );
1070     }
1071     else
1072     {
1073       DALI_SCRIPT_WARNING("Cannot find camera actor on stage for render task called '%s'\n", (*s).c_str() );
1074     }
1075   }
1076
1077   if( OptionalString s = constant.IsString( IsChild(node, "screenToFrameBufferFunction") ) )
1078   {
1079     if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
1080     {
1081       task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
1082     }
1083     else if("FULLSCREEN_FRAMEBUFFER_FUNCTION" == *s)
1084     {
1085       task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
1086     }
1087     else
1088     {
1089       DALI_SCRIPT_WARNING("todo");
1090     }
1091   }
1092
1093   // other setup is via the property system
1094   SetProperties( node, task, constant );
1095 }
1096
1097 bool Builder::ApplyStyle( const std::string& styleName, Handle& handle, const Replacement& replacement )
1098 {
1099   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1100
1101   OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
1102
1103   std::string styleNameLower(styleName);
1104   OptionalChild style  = IsChildIgnoreCase( *styles, styleNameLower );
1105
1106   if( styles && style )
1107   {
1108     ApplyAllStyleProperties( *mParser.GetRoot(), *style, handle, replacement );
1109     return true;
1110   }
1111   else
1112   {
1113     return false;
1114   }
1115 }
1116
1117 void Builder::ApplyAllStyleProperties( const TreeNode& root, const TreeNode& node,
1118                                        Dali::Handle& handle, const Replacement& constant )
1119 {
1120   const char* styleName = node.GetName();
1121
1122   StylePtr style = Style::New();
1123
1124   StylePtr* matchedStyle = NULL;
1125   if( styleName )
1126   {
1127     matchedStyle = mStyles.Find( styleName );
1128     if( ! matchedStyle )
1129     {
1130       OptionalChild styleNodes = IsChild(root, KEYNAME_STYLES);
1131       OptionalChild inheritFromNode = IsChild(node, KEYNAME_INHERIT);
1132       if( !inheritFromNode )
1133       {
1134         inheritFromNode = IsChild( node, KEYNAME_STYLES );
1135       }
1136
1137       if( styleNodes )
1138       {
1139         if( inheritFromNode )
1140         {
1141           TreeNodeList additionalStyleNodes;
1142
1143           CollectAllStyles( *styleNodes, *inheritFromNode, additionalStyleNodes );
1144
1145 #if defined(DEBUG_ENABLED)
1146           for(TreeNode::ConstIterator iter = (*inheritFromNode).CBegin(); iter != (*inheritFromNode).CEnd(); ++iter)
1147           {
1148             if( OptionalString styleName = IsString( (*iter).second ) )
1149             {
1150               DALI_SCRIPT_VERBOSE("Style Applied '%s'\n", (*styleName).c_str());
1151             }
1152           }
1153 #endif
1154
1155           // a style may have other styles, which has other styles etc so we apply in reverse by convention.
1156           for(TreeNodeList::reverse_iterator iter = additionalStyleNodes.rbegin(); iter != additionalStyleNodes.rend(); ++iter)
1157           {
1158             RecordStyle( style, *(*iter), handle, constant );
1159             ApplySignals( root, *(*iter), handle );
1160             ApplyStylesByActor( root, *(*iter), handle, constant );
1161           }
1162         }
1163
1164         RecordStyle( style, node, handle, constant );
1165         mStyles.Add( styleName, style ); // shallow copy
1166         matchedStyle = &style;
1167       }
1168     }
1169   }
1170
1171   if( matchedStyle )
1172   {
1173     StylePtr style( *matchedStyle );
1174     Dictionary<Property::Map> instancedProperties;
1175     style->ApplyVisualsAndPropertiesRecursively( handle, instancedProperties );
1176   }
1177   else // If there were no styles, instead set properties
1178   {
1179     SetProperties( node, handle, constant );
1180   }
1181   ApplySignals( root, node, handle );
1182   ApplyStylesByActor( root, node, handle, constant );
1183 }
1184
1185 void Builder::RecordStyle( StylePtr           style,
1186                            const TreeNode&    node,
1187                            Dali::Handle&      handle,
1188                            const Replacement& replacements )
1189 {
1190   // With repeated calls, accumulate inherited states, visuals and properties
1191   // but override any with same name
1192
1193   for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
1194   {
1195     const TreeNode::KeyNodePair& keyValue = *iter;
1196     std::string key( keyValue.first );
1197     if( key == KEYNAME_STATES )
1198     {
1199       const TreeNode& states = keyValue.second;
1200       if( states.GetType() != TreeNode::OBJECT )
1201       {
1202         DALI_LOG_WARNING( "RecordStyle() Node \"%s\" is not a JSON object\n", key.c_str() );
1203         continue;
1204       }
1205
1206       for( TreeNode::ConstIterator iter = states.CBegin(); iter != states.CEnd(); ++iter )
1207       {
1208         const TreeNode& stateNode = (*iter).second;
1209         const char* stateName = stateNode.GetName();
1210         if( stateNode.GetType() != TreeNode::OBJECT )
1211         {
1212           DALI_LOG_WARNING( "RecordStyle() Node \"%s\" is not a JSON object\n", stateName );
1213           continue;
1214         }
1215
1216         StylePtr* stylePtr = style->subStates.Find( stateName );
1217         if( stylePtr )
1218         {
1219           StylePtr style(*stylePtr);
1220           RecordStyle( style, stateNode, handle, replacements );
1221         }
1222         else
1223         {
1224           StylePtr subState = Style::New();
1225           RecordStyle( subState, stateNode, handle, replacements );
1226           style->subStates.Add( stateName, subState );
1227         }
1228       }
1229     }
1230     else if( key == KEYNAME_VISUALS )
1231     {
1232       for( TreeNode::ConstIterator iter = keyValue.second.CBegin(); iter != keyValue.second.CEnd(); ++iter )
1233       {
1234         // Each key in this table should be a property name matching a visual.
1235         const TreeNode::KeyNodePair& visual = *iter;
1236         Dali::Property::Value property(Property::MAP);
1237         if( DeterminePropertyFromNode( visual.second, Property::MAP, property, replacements ) )
1238         {
1239           Property::Map* mapPtr = style->visuals.Find( visual.first );
1240           if( mapPtr )
1241           {
1242             // Override existing visuals
1243             mapPtr->Clear();
1244             mapPtr->Merge( *property.GetMap() );
1245           }
1246           else
1247           {
1248             Property::Map* map = property.GetMap();
1249             if( map )
1250             {
1251               style->visuals.Add( visual.first, *map );
1252             }
1253           }
1254         }
1255       }
1256     }
1257     else if( key == KEYNAME_ENTRY_TRANSITION )
1258     {
1259       RecordTransitionData( keyValue, style->entryTransition, replacements );
1260     }
1261     else if( key == KEYNAME_EXIT_TRANSITION )
1262     {
1263       RecordTransitionData( keyValue, style->exitTransition, replacements );
1264     }
1265     else if( key == KEYNAME_TRANSITIONS )
1266     {
1267       RecordTransitions( keyValue, style->transitions, replacements );
1268     }
1269     else if( key == KEYNAME_TYPE ||
1270              key == KEYNAME_ACTORS ||
1271              key == KEYNAME_SIGNALS ||
1272              key == KEYNAME_STYLES ||
1273              key == KEYNAME_MAPPINGS ||
1274              key == KEYNAME_INHERIT )
1275     {
1276       continue;
1277     }
1278     else // It's a property
1279     {
1280       Property::Index index;
1281       Property::Value value;
1282       if( MapToTargetProperty( handle, key, keyValue.second, replacements, index, value ) )
1283       {
1284         Property::Value* existingValuePtr = style->properties.Find( index );
1285         if( existingValuePtr != NULL )
1286         {
1287           *existingValuePtr = value; // Overwrite existing property.
1288         }
1289         else
1290         {
1291           style->properties.Add( index, value );
1292         }
1293       }
1294     }
1295   }
1296 }
1297
1298 void Builder::RecordTransitions(
1299   const TreeNode::KeyNodePair& keyValue,
1300   Property::Array& value,
1301   const Replacement& replacements )
1302 {
1303   //@todo add new transitions to style.transitions
1304   //      override existing transitions. A transition matches on target & property name
1305   const TreeNode& node = keyValue.second;
1306   if( node.GetType() == TreeNode::ARRAY )
1307   {
1308     Dali::Property::Value property(Property::ARRAY);
1309     if( DeterminePropertyFromNode( node, Property::ARRAY, property, replacements ) )
1310     {
1311       value = *property.GetArray();
1312     }
1313   }
1314   else if( node.GetType() == TreeNode::OBJECT )
1315   {
1316     Dali::Property::Value property(Property::MAP);
1317     if( DeterminePropertyFromNode( node, Property::MAP, property, replacements ) )
1318     {
1319       Property::Array propertyArray;
1320       propertyArray.Add( property );
1321       value = propertyArray;
1322     }
1323   }
1324   else
1325   {
1326     DALI_LOG_WARNING( "RecordStyle() Node \"%s\" is not a JSON array or object\n", keyValue.first );
1327   }
1328 }
1329
1330 void Builder::RecordTransitionData(
1331   const TreeNode::KeyNodePair& keyValue,
1332   Toolkit::TransitionData& transitionData,
1333   const Replacement& replacements )
1334 {
1335   const TreeNode& node = keyValue.second;
1336   if( node.GetType() == TreeNode::ARRAY )
1337   {
1338     Dali::Property::Value property(Property::ARRAY);
1339     if( DeterminePropertyFromNode( keyValue.second, Property::ARRAY, property, replacements ) )
1340     {
1341       transitionData = Toolkit::TransitionData::New( *property.GetArray() );
1342     }
1343   }
1344   else if( node.GetType() == TreeNode::OBJECT )
1345   {
1346     Dali::Property::Value property(Property::MAP);
1347     if( DeterminePropertyFromNode( keyValue.second, Property::MAP, property, replacements ) )
1348     {
1349       transitionData = Toolkit::TransitionData::New( *property.GetMap() );
1350     }
1351   }
1352 }
1353
1354
1355 // Set properties from node on handle.
1356 void Builder::ApplyProperties( const TreeNode& root, const TreeNode& node,
1357                                Dali::Handle& handle, const Replacement& constant )
1358 {
1359   SetProperties( node, handle, constant );
1360   ApplySignals( root, node, handle );
1361 }
1362
1363 void Builder::ApplySignals(const TreeNode& root, const TreeNode& node, Dali::Handle& handle )
1364 {
1365   Actor actor = Actor::DownCast(handle);
1366   if( actor )
1367   {
1368     // add signals
1369     SetupSignalAction( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
1370     SetupPropertyNotification( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
1371   }
1372 }
1373
1374
1375 // Appling by style helper
1376 // use FindChildByName() to apply properties referenced in KEYNAME_ACTORS in the node
1377 void Builder::ApplyStylesByActor(  const TreeNode& root, const TreeNode& node,
1378                                    Dali::Handle& handle, const Replacement& constant )
1379 {
1380   if( Dali::Actor actor = Dali::Actor::DownCast( handle ) )
1381   {
1382     if( const TreeNode* actors = node.GetChild( KEYNAME_ACTORS ) )
1383     {
1384       // in a style the actor subtree properties referenced by actor name
1385       for( TreeConstIter iter = actors->CBegin(); iter != actors->CEnd(); ++iter )
1386       {
1387         Dali::Actor foundActor;
1388
1389         if( (*iter).first )
1390         {
1391           foundActor = actor.FindChildByName( (*iter).first );
1392         }
1393
1394         if( !foundActor )
1395         {
1396           DALI_SCRIPT_VERBOSE("Cannot find actor in style application '%s'\n", (*iter).first);
1397         }
1398         else
1399         {
1400           DALI_SCRIPT_VERBOSE("Styles applied to actor '%s'\n", (*iter).first);
1401           ApplyProperties( root, (*iter).second, foundActor, constant );
1402         }
1403       }
1404     }
1405   }
1406 }
1407
1408 /*
1409  * Sets the handle properties found in the tree node
1410  */
1411 void Builder::SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant )
1412 {
1413   if( handle )
1414   {
1415     for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
1416     {
1417       const TreeNode::KeyNodePair& keyChild = *iter;
1418
1419       std::string key( keyChild.first );
1420
1421       // ignore special fields;
1422       if( key == KEYNAME_TYPE ||
1423           key == KEYNAME_ACTORS ||
1424           key == KEYNAME_SIGNALS ||
1425           key == KEYNAME_STYLES ||
1426           key == KEYNAME_MAPPINGS ||
1427           key == KEYNAME_INHERIT ||
1428           key == KEYNAME_STATES ||
1429           key == KEYNAME_VISUALS ||
1430           key == KEYNAME_ENTRY_TRANSITION ||
1431           key == KEYNAME_EXIT_TRANSITION ||
1432           key == KEYNAME_TRANSITIONS )
1433       {
1434         continue;
1435       }
1436
1437       Property::Index index;
1438       Property::Value value;
1439
1440       bool mapped = MapToTargetProperty( handle, key, keyChild.second, constant, index, value );
1441       if( mapped )
1442       {
1443         DALI_SCRIPT_VERBOSE("SetProperty '%s' Index=:%d Value Type=%d Value '%s'\n", key.c_str(), index, value.GetType(), PropertyValueToString(value).c_str() );
1444
1445         handle.SetProperty( index, value );
1446       }
1447
1448       // Add custom properties
1449       SetCustomProperties(node, handle, constant, PROPERTIES, Property::READ_WRITE);
1450       SetCustomProperties(node, handle, constant, ANIMATABLE_PROPERTIES, Property::ANIMATABLE);
1451
1452     } // for property nodes
1453   }
1454   else
1455   {
1456     DALI_SCRIPT_WARNING("Style applied to empty handle\n");
1457   }
1458 }
1459
1460 bool Builder::MapToTargetProperty(
1461   Handle&            propertyObject,
1462   const std::string& key,
1463   const TreeNode&    node,
1464   const Replacement& constant,
1465   Property::Index&   index,
1466   Property::Value&   value )
1467 {
1468   bool mapped = false;
1469
1470   index = propertyObject.GetPropertyIndex( key );
1471   if( Property::INVALID_INDEX != index )
1472   {
1473     Property::Type type = propertyObject.GetPropertyType(index);
1474
1475     // if node.value is a mapping, get the property value from the "mappings" table
1476     if( node.GetType() == TreeNode::STRING )
1477     {
1478       std::string mappingKey;
1479       if( GetMappingKey( node.GetString(), mappingKey) )
1480       {
1481         OptionalChild mappingRoot = IsChild( mParser.GetRoot(), KEYNAME_MAPPINGS );
1482         mapped = GetPropertyMap( *mappingRoot, mappingKey.c_str(), type, value );
1483       }
1484     }
1485     if( ! mapped )
1486     {
1487       mapped = DeterminePropertyFromNode( node, type, value, constant );
1488       if( ! mapped )
1489       {
1490         // Just determine the property from the node and if it's valid, let the property object handle it
1491         DeterminePropertyFromNode( node, value, constant );
1492         mapped = ( value.GetType() != Property::NONE );
1493       }
1494     }
1495   }
1496   else
1497   {
1498     DALI_LOG_ERROR("Key '%s' not found.\n", key.c_str());
1499   }
1500   return mapped;
1501 }
1502
1503 bool Builder::GetPropertyMap( const TreeNode& mappingRoot, const char* theKey, Property::Type propertyType, Property::Value& value )
1504 {
1505   KeyStack keyStack;
1506   return RecursePropertyMap( mappingRoot, keyStack, theKey, propertyType, value );
1507 }
1508
1509 bool Builder::RecursePropertyMap( const TreeNode& mappingRoot, KeyStack& keyStack, const char* theKey, Property::Type propertyType, Property::Value& value )
1510 {
1511   Replacement replacer( mReplacementMap );
1512   bool result = false;
1513
1514   keyStack.push_back( theKey );
1515
1516   for( TreeNode::ConstIterator iter = mappingRoot.CBegin(); iter != mappingRoot.CEnd(); ++iter )
1517   {
1518     std::string aKey( (*iter).first );
1519     if( aKey.compare( theKey ) == 0 )
1520     {
1521       if( propertyType == Property::NONE )
1522       {
1523         DeterminePropertyFromNode( (*iter).second, value, replacer );
1524         result = true;
1525       }
1526       else
1527       {
1528         result = DeterminePropertyFromNode( (*iter).second, propertyType, value, replacer );
1529       }
1530
1531       if( result )
1532       {
1533         ConvertChildValue(mappingRoot, keyStack, value);
1534       }
1535       break;
1536     }
1537   }
1538   keyStack.pop_back();
1539
1540   return result;
1541 }
1542
1543 bool Builder::ConvertChildValue( const TreeNode& mappingRoot, KeyStack& keyStack, Property::Value& child )
1544 {
1545   bool result = false;
1546
1547   switch( child.GetType() )
1548   {
1549     case Property::STRING:
1550     {
1551       std::string value;
1552       if( child.Get( value ) )
1553       {
1554         std::string key;
1555         if( GetMappingKey( value, key ) )
1556         {
1557           // Check key for cycles:
1558           result=true;
1559           for( KeyStack::iterator iter = keyStack.begin() ; iter != keyStack.end(); ++iter )
1560           {
1561             if( key.compare(*iter) == 0 )
1562             {
1563               // key is already in stack; stop.
1564               DALI_LOG_WARNING("Detected cycle in stylesheet mapping table:%s\n", key.c_str());
1565               child = Property::Value("");
1566               result=false;
1567               break;
1568             }
1569           }
1570
1571           if( result )
1572           {
1573             // The following call will overwrite the child with the value
1574             // from the mapping.
1575             RecursePropertyMap( mappingRoot, keyStack, key.c_str(), Property::NONE, child );
1576             result = true;
1577           }
1578         }
1579       }
1580       break;
1581     }
1582
1583     case Property::MAP:
1584     {
1585       Property::Map* map = child.GetMap();
1586       if( map )
1587       {
1588         for( Property::Map::SizeType i=0; i < map->Count(); ++i )
1589         {
1590           Property::Value& child = map->GetValue(i);
1591           ConvertChildValue(mappingRoot, keyStack, child);
1592         }
1593       }
1594       break;
1595     }
1596
1597     case Property::ARRAY:
1598     {
1599       Property::Array* array = child.GetArray();
1600       if( array )
1601       {
1602         for( Property::Array::SizeType i=0; i < array->Count(); ++i )
1603         {
1604           Property::Value& child = array->GetElementAt(i);
1605           ConvertChildValue(mappingRoot, keyStack, child);
1606         }
1607       }
1608       break;
1609     }
1610
1611     default:
1612       // Ignore other types.
1613       break;
1614   }
1615
1616   return result;
1617 }
1618
1619 void Builder::SetCustomProperties( const TreeNode& node, Handle& handle, const Replacement& constant,
1620                           const std::string& childName, Property::AccessMode accessMode )
1621 {
1622   // Add custom properties
1623   if( OptionalChild customPropertiesChild = IsChild(node, childName) )
1624   {
1625     const TreeNode& customPropertiesNode = *customPropertiesChild;
1626     const TreeConstIter endIter = customPropertiesNode.CEnd();
1627     for( TreeConstIter iter = customPropertiesNode.CBegin(); endIter != iter; ++iter )
1628     {
1629       const TreeNode::KeyNodePair& keyChild = *iter;
1630       std::string key( keyChild.first );
1631       Property::Value value;
1632       DeterminePropertyFromNode( keyChild.second, value, constant );
1633
1634       // Register/Set property.
1635       handle.RegisterProperty( key, value, accessMode );
1636     }
1637   }
1638 }
1639
1640
1641 } // namespace Internal
1642
1643 } // namespace Toolkit
1644
1645 } // namespace Dali