dali-toolkit/internal/builder/builder-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-toolkit/internal/builder/builder-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <sys/stat.h>
  23 #include <sstream>
  24 #include <dali/public-api/render-tasks/render-task-list.h>
  25 #include <dali/public-api/object/type-info.h>
  26 #include <dali/public-api/object/type-registry.h>
  27 #include <dali/public-api/object/property-array.h>
  28 #include <dali/public-api/actors/layer.h>
  29 #include <dali/public-api/actors/image-actor.h>
  30 #include <dali/public-api/actors/camera-actor.h>
  31 #include <dali/devel-api/scripting/scripting.h>
  32 #include <dali/public-api/signals/functor-delegate.h>
  33 #include <dali/integration-api/debug.h>
  34
  35 // INTERNAL INCLUDES
  36 #include <dali-toolkit/public-api/controls/control.h>
  37 #include <dali-toolkit/devel-api/builder/json-parser.h>
  38
  39 #include <dali-toolkit/internal/builder/builder-get-is.inl.h>
  40 #include <dali-toolkit/internal/builder/builder-filesystem.h>
  41 #include <dali-toolkit/internal/builder/builder-declarations.h>
  42 #include <dali-toolkit/internal/builder/replacement.h>
  43
  44 namespace Dali
  45 {
  46
  47 namespace Toolkit
  48 {
  49
  50 namespace Internal
  51 {
  52 class Replacement;
  53
  54 extern Animation CreateAnimation(const TreeNode& child, const Replacement& replacements, const Dali::Actor searchRoot, Builder* const builder );
  55 extern bool SetPropertyFromNode( const TreeNode& node, Property::Value& value );
  56 extern bool SetPropertyFromNode( const TreeNode& node, Property::Value& value, const Replacement& replacements );
  57 extern bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value );
  58 extern bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value, const Replacement& replacements );
  59 extern Actor SetupSignalAction(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder);
  60 extern Actor SetupPropertyNotification(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor, Dali::Toolkit::Internal::Builder* const builder);
  61 extern Actor SetupActor( const TreeNode& node, Actor& actor, const Replacement& constant );
  62
  63 #if defined(DEBUG_ENABLED)
  64 Integration::Log::Filter* gFilterScript  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_SCRIPT");
  65 #endif
  66
  67 namespace
  68 {
  69
  70 #define TOKEN_STRING(x) #x
  71
  72 const std::string KEYNAME_STYLES    = "styles";
  73 const std::string KEYNAME_TYPE      = "type";
  74 const std::string KEYNAME_ACTORS    = "actors";
  75 const std::string KEYNAME_SIGNALS   = "signals";
  76 const std::string KEYNAME_NAME      = "name";
  77 const std::string KEYNAME_TEMPLATES = "templates";
  78 const std::string KEYNAME_INCLUDES  = "includes";
  79
  80 typedef std::vector<const TreeNode*> TreeNodeList;
  81
  82 template <typename T>
  83 std::string ToString(const T& value)
  84 {
  85   std::stringstream ss;
  86   ss << value;
  87   return ss.str();
  88 }
  89
  90 template <>
  91 std::string ToString(const Rect<int>& value)
  92 {
  93   std::stringstream ss;
  94   ss << value.x << "," << value.y << "," << value.width << "," << value.height;
  95   return ss.str();
  96 }
  97
  98 #if defined(DEBUG_ENABLED)
  99
 100 std::string PropertyValueToString( const Property::Value& value )
 101 {
 102   std::string ret;
 103
 104   switch( value.GetType() )
 105   {
 106     case Property::NONE:
 107     {
 108       ret = "NONE";
 109       break;
 110     }            ///< No type
 111     case Property::BOOLEAN:
 112     {
 113       ret = value.Get<bool>() ? "True" : "False";
 114       break;
 115     }
 116     case Property::FLOAT:
 117     {
 118
 119       ret = ToString( value.Get<float>() );
 120       break;
 121     }
 122     case Property::INTEGER:
 123     {
 124       ret = ToString( value.Get<int>() );
 125       break;
 126     }
 127     case Property::VECTOR2:
 128     {
 129       ret = ToString( value.Get<Vector2>() );
 130       break;
 131     }
 132     case Property::VECTOR3:
 133     {
 134       ret = ToString( value.Get<Vector3>() );
 135       break;
 136     }
 137     case Property::VECTOR4:
 138     {
 139       ret = ToString( value.Get<Vector4>() );
 140       break;
 141     }
 142     case Property::MATRIX3:
 143     {
 144       ret = ToString( value.Get<Matrix3>() );
 145       break;
 146     }
 147     case Property::MATRIX:
 148     {
 149       ret = ToString( value.Get<Matrix>() );
 150       break;
 151     }
 152     case Property::RECTANGLE:
 153     {
 154       ret = ToString( value.Get< Rect<int> >() );
 155       break;
 156     }
 157     case Property::ROTATION:
 158     {
 159       break;
 160     }
 161     case Property::STRING:
 162     {
 163       ret = value.Get<std::string>();
 164       break;
 165     }
 166     case Property::ARRAY:
 167     {
 168       ret = std::string("Array Size=") + ToString( value.Get<Property::Array>().Size() );
 169       break;
 170     }
 171     case Property::MAP:
 172     {
 173       ret = std::string("Map Size=") + ToString( value.Get<Property::Map>().Count() );
 174       break;
 175     }
 176   }
 177
 178   return ret;
 179 }
 180 #endif // DEBUG_ENABLED
 181
 182 /*
 183  * Recursively collects all stylesin a node (An array of style names).
 184  *
 185  * stylesCollection The set of styles from the json file (a json object of named styles)
 186  * style The style array to begin the collection from
 187  * styleList The style list to add nodes to apply
 188  */
 189 void CollectAllStyles( const TreeNode& stylesCollection, const TreeNode& style, TreeNodeList& styleList )
 190 {
 191   // style is an array of style names
 192   if( TreeNode::ARRAY == style.GetType() )
 193   {
 194     for(TreeNode::ConstIterator iter = style.CBegin(); iter != style.CEnd(); ++iter)
 195     {
 196       if( OptionalString styleName = IsString( (*iter).second ) )
 197       {
 198         if( OptionalChild node = IsChild( stylesCollection, *styleName) )
 199         {
 200           styleList.push_back( &(*node) );
 201
 202           if( OptionalChild subStyle = IsChild( *node, KEYNAME_STYLES ) )
 203           {
 204             CollectAllStyles( stylesCollection, *subStyle, styleList );
 205           }
 206         }
 207       }
 208     }
 209   }
 210 }
 211
 212
 213 } // namespace anon
 214
 215 /*
 216  * Sets the handle properties found in the tree node
 217  */
 218 void Builder::SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant )
 219 {
 220   if( handle )
 221   {
 222     for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
 223     {
 224       const TreeNode::KeyNodePair& keyChild = *iter;
 225
 226       std::string key( keyChild.first );
 227
 228       // ignore special fields; type,actors,signals,styles
 229       if(key == KEYNAME_TYPE || key == KEYNAME_ACTORS || key == KEYNAME_SIGNALS || key == KEYNAME_STYLES)
 230       {
 231         continue;
 232       }
 233
 234       // special field 'image' usually contains an json object description
 235       // although sometimes refers to a framebuffer
 236       if( 0 == keyChild.second.Size() )
 237       {
 238         if(key == "image")
 239         {
 240           ImageActor imageActor = ImageActor::DownCast(handle);
 241           if(imageActor)
 242           {
 243             if( OptionalString s = constant.IsString( keyChild.second ) )
 244             {
 245               FrameBufferImage fb = GetFrameBufferImage(*s, constant);
 246               if(fb)
 247               {
 248                 imageActor.SetImage( fb );
 249               }
 250             }
 251           }
 252         }
 253       }
 254
 255       // special field 'effect' references the shader effect instances
 256       if(key == "effect")
 257       {
 258         ImageActor actor = ImageActor::DownCast(handle);
 259         if( actor )
 260         {
 261           OptionalString str = constant.IsString( keyChild.second );
 262           if( str )
 263           {
 264             ShaderEffect effect = GetShaderEffect( *str, constant );
 265             actor.SetShaderEffect(effect);
 266           }
 267         }
 268         else
 269         {
 270           DALI_SCRIPT_WARNING("Could not find or set shader effect\n");
 271         }
 272
 273         continue;
 274       }
 275
 276       Handle propertyObject( handle );
 277
 278       Dali::Property::Index index = propertyObject.GetPropertyIndex( key );
 279
 280       if( Property::INVALID_INDEX == index )
 281       {
 282         ImageActor actor = ImageActor::DownCast(handle);
 283         if( actor )
 284         {
 285           if( ShaderEffect effect = actor.GetShaderEffect() )
 286           {
 287             index = effect.GetPropertyIndex( key );
 288             if(index != Property::INVALID_INDEX)
 289             {
 290               propertyObject = effect;
 291             }
 292           }
 293         }
 294       }
 295
 296       if( Property::INVALID_INDEX != index )
 297       {
 298         Property::Type type = propertyObject.GetPropertyType(index);
 299
 300         Property::Value value;
 301         if( !SetPropertyFromNode( keyChild.second, type, value, constant ) )
 302         {
 303           // verbose as this might not be a problem
 304           // eg parentOrigin can be a string which is picked up later
 305           DALI_SCRIPT_VERBOSE("Could not convert property:%s\n", key.c_str());
 306         }
 307         else
 308         {
 309           DALI_SCRIPT_VERBOSE("SetProperty '%s' Index=:%d Value Type=%d Value '%s'\n", key.c_str(), index, value.GetType(), PropertyValueToString(value).c_str() );
 310
 311           propertyObject.SetProperty( index, value );
 312         }
 313       }
 314       else
 315       {
 316         DALI_SCRIPT_VERBOSE("SetProperty INVALID '%s' Index=:%d\n", key.c_str(), index);
 317       }
 318
 319     } // for property nodes
 320   }
 321   else
 322   {
 323     DALI_SCRIPT_WARNING("Style applied to empty handle\n");
 324   }
 325 }
 326
 327 // Set properties from node on handle.
 328 void Builder::ApplyProperties( const TreeNode& root, const TreeNode& node,
 329                                Dali::Handle& handle, const Replacement& constant )
 330 {
 331   if( Actor actor = Actor::DownCast(handle) )
 332   {
 333     SetProperties( node, actor, constant );
 334
 335     if( actor )
 336     {
 337       SetupActor( node, actor, constant );
 338
 339       // add signals
 340       SetupSignalAction( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
 341       SetupPropertyNotification( mSlotDelegate.GetConnectionTracker(), root, node, actor, this );
 342    }
 343   }
 344   else
 345   {
 346     SetProperties( node, handle, constant );
 347   }
 348 }
 349
 350 // Appling by style helper
 351 // use FindChildByName() to apply properties referenced in KEYNAME_ACTORS in the node
 352 void Builder::ApplyStylesByActor(  const TreeNode& root, const TreeNode& node,
 353                                    Dali::Handle& handle, const Replacement& constant )
 354 {
 355   if( Dali::Actor actor = Dali::Actor::DownCast( handle ) )
 356   {
 357     if( const TreeNode* actors = node.GetChild( KEYNAME_ACTORS ) )
 358     {
 359       // in a style the actor subtree properties referenced by actor name
 360       for( TreeConstIter iter = actors->CBegin(); iter != actors->CEnd(); ++iter )
 361       {
 362         Dali::Actor foundActor;
 363
 364         if( (*iter).first )
 365         {
 366           foundActor = actor.FindChildByName( (*iter).first );
 367         }
 368
 369         if( !foundActor )
 370         {
 371           // debug log cannot find searched for actor
 372 #if defined(DEBUG_ENABLED)
 373           DALI_SCRIPT_VERBOSE("Cannot find actor in style application '%s'\n", (*iter).first);
 374 #endif
 375         }
 376         else
 377         {
 378 #if defined(DEBUG_ENABLED)
 379           DALI_SCRIPT_VERBOSE("Styles applied to actor '%s'\n", (*iter).first);
 380 #endif
 381           ApplyProperties( root, (*iter).second, foundActor, constant );
 382         }
 383       }
 384     }
 385   }
 386 }
 387
 388
 389 void Builder::ApplyAllStyleProperties( const TreeNode& root, const TreeNode& node,
 390                                        Dali::Handle& handle, const Replacement& constant )
 391 {
 392   OptionalChild styles = IsChild(root, KEYNAME_STYLES);
 393   OptionalChild style  = IsChild(node, KEYNAME_STYLES);
 394
 395   if( styles && style )
 396   {
 397     TreeNodeList additionalStyles;
 398
 399     CollectAllStyles( *styles, *style, additionalStyles );
 400
 401 #if defined(DEBUG_ENABLED)
 402     for(TreeNode::ConstIterator iter = (*style).CBegin(); iter != (*style).CEnd(); ++iter)
 403     {
 404       if( OptionalString styleName = IsString( (*iter).second ) )
 405       {
 406         DALI_SCRIPT_VERBOSE("Style Applied '%s'\n", (*styleName).c_str());
 407       }
 408     }
 409 #endif
 410
 411     // a style may have other styles, which has other styles etc so we apply in reverse by convention.
 412     for(TreeNodeList::reverse_iterator iter = additionalStyles.rbegin(); iter != additionalStyles.rend(); ++iter)
 413     {
 414       ApplyProperties( root, *(*iter), handle, constant );
 415
 416       ApplyStylesByActor( root, *(*iter), handle, constant );
 417     }
 418   }
 419
 420   // applying given node last
 421   ApplyProperties( root, node, handle, constant );
 422
 423   ApplyStylesByActor( root, node, handle, constant );
 424
 425 }
 426
 427
 428 /*
 429  * Create a dali type from a node.
 430  * If parent given and an actor type was created then add it to the parent and
 431  * recursively add nodes children.
 432  */
 433 BaseHandle Builder::DoCreate( const TreeNode& root, const TreeNode& node,
 434                               Actor parent, const Replacement& replacements )
 435 {
 436   BaseHandle baseHandle;
 437   TypeInfo typeInfo;
 438   const TreeNode* templateNode = NULL;
 439
 440   if( OptionalString typeName = IsString(node, KEYNAME_TYPE) )
 441   {
 442     typeInfo = TypeRegistry::Get().GetTypeInfo( *typeName );
 443
 444     if( !typeInfo )
 445     {
 446       // a template name is also allowed inplace of the type name
 447       OptionalChild templates = IsChild( root, KEYNAME_TEMPLATES);
 448
 449       if( templates )
 450       {
 451         if( OptionalChild isTemplate = IsChild( *templates, *typeName ) )
 452         {
 453           templateNode = &(*isTemplate);
 454
 455           if( OptionalString templateTypeName = IsString(*templateNode, KEYNAME_TYPE) )
 456           {
 457             typeInfo = TypeRegistry::Get().GetTypeInfo( *templateTypeName );
 458           }
 459         }
 460       }
 461     }
 462   }
 463
 464   if(!typeInfo)
 465   {
 466     DALI_SCRIPT_WARNING("Cannot create Dali type from node '%s'\n", node.GetName());
 467   }
 468   else
 469   {
 470     baseHandle       = typeInfo.CreateInstance();
 471     Handle handle    = Handle::DownCast(baseHandle);
 472     Actor actor      = Actor::DownCast(handle);
 473
 474     if(handle)
 475     {
 476
 477       DALI_SCRIPT_VERBOSE("Create:%s\n", typeInfo.GetName().c_str());
 478
 479 #if defined(DEBUG_ENABLED)
 480       if(handle)
 481       {
 482         DALI_SCRIPT_VERBOSE("  Is Handle Object=%d\n", (long*)handle.GetObjectPtr());
 483         DALI_SCRIPT_VERBOSE("  Is Handle Property Count=%d\n", handle.GetPropertyCount());
 484       }
 485
 486       if(actor)
 487       {
 488         DALI_SCRIPT_VERBOSE("  Is Actor id=%d\n", actor.GetId());
 489       }
 490
 491       Toolkit::Control control  = Toolkit::Control::DownCast(handle);
 492       if(control)
 493       {
 494         DALI_SCRIPT_VERBOSE("  Is Control id=%d\n", actor.GetId());
 495       }
 496 #endif // DEBUG_ENABLED
 497
 498       if( templateNode )
 499       {
 500         ApplyProperties( root, *templateNode, handle, replacements );
 501
 502         if( OptionalChild actors = IsChild( *templateNode, KEYNAME_ACTORS ) )
 503         {
 504           for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
 505           {
 506             DoCreate( root, (*iter).second, actor, replacements );
 507           }
 508         }
 509       }
 510
 511       if( actor )
 512       {
 513         // add children of all the styles
 514         if( OptionalChild actors = IsChild( node, KEYNAME_ACTORS ) )
 515         {
 516           for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
 517           {
 518             DoCreate( root, (*iter).second, actor, replacements );
 519           }
 520         }
 521
 522         // apply style on top as they need the children to exist
 523         ApplyAllStyleProperties( root, node, actor, replacements );
 524
 525         // then add to parent
 526         if( parent )
 527         {
 528           parent.Add( actor );
 529         }
 530       }
 531       else
 532       {
 533         ApplyProperties( root, node, handle, replacements );
 534       }
 535     }
 536     else
 537     {
 538       DALI_SCRIPT_WARNING("Cannot create handle from type '%s'\n", typeInfo.GetName().c_str());
 539     }
 540   }
 541
 542   return baseHandle;
 543 }
 544
 545 void Builder::SetupTask( RenderTask& task, const TreeNode& node, const Replacement& constant )
 546 {
 547   const Stage& stage = Stage::GetCurrent();
 548   Layer root  = stage.GetRootLayer();
 549
 550   if( OptionalString s = constant.IsString( IsChild(node, "sourceActor") ) )
 551   {
 552     Actor actor = root.FindChildByName(*s);
 553     if(actor)
 554     {
 555       task.SetSourceActor( actor );
 556     }
 557     else
 558     {
 559       DALI_SCRIPT_WARNING("Cannot find source actor on stage for render task called '%s'\n", (*s).c_str() );
 560     }
 561   }
 562
 563   if( OptionalString s = constant.IsString( IsChild(node, "cameraActor") ) )
 564   {
 565     CameraActor actor = CameraActor::DownCast( root.FindChildByName(*s) );
 566     if(actor)
 567     {
 568       task.SetCameraActor( actor );
 569     }
 570     else
 571     {
 572       DALI_SCRIPT_WARNING("Cannot find camera actor on stage for render task called '%s'\n", (*s).c_str() );
 573     }
 574   }
 575
 576   if( OptionalString s = constant.IsString( IsChild(node, "targetFrameBuffer") ) )
 577   {
 578     FrameBufferImage fb = GetFrameBufferImage( *s, constant );
 579     if(fb)
 580     {
 581       task.SetTargetFrameBuffer( fb );
 582     }
 583     else
 584     {
 585       DALI_SCRIPT_WARNING("Cannot find target frame buffer '%s'\n", (*s).c_str() );
 586     }
 587   }
 588
 589   if( OptionalString s = constant.IsString( IsChild(node, "screenToFrameBufferFunction") ) )
 590   {
 591     if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
 592     {
 593       task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
 594     }
 595     else if("FULLSCREEN_FRAMEBUFFER_FUNCTION" == *s)
 596     {
 597       task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
 598     }
 599     else
 600     {
 601       DALI_SCRIPT_WARNING("todo");
 602     }
 603   }
 604
 605   // other setup is via the property system
 606   SetProperties( node, task, constant );
 607 }
 608
 609 void Builder::CreateRenderTask( const std::string &name )
 610 {
 611   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 612
 613   Replacement constant(mReplacementMap);
 614
 615   const Stage& stage = Stage::GetCurrent();
 616
 617   OptionalChild tasks = IsChild(*mParser.GetRoot(), "renderTasks");
 618
 619   if(tasks)
 620   {
 621     //
 622     // Create the tasks from the current task as generally we want
 623     // to setup task zero and onwards. Although this does overwrite
 624     // the properties of the current task.
 625     //
 626     if( OptionalChild renderTask = IsChild(*tasks, name ) )
 627     {
 628       RenderTaskList list = stage.GetRenderTaskList();
 629       unsigned int start = list.GetTaskCount();
 630
 631       RenderTask task;
 632       if(0 == start)
 633       {
 634         // zero should have already been created by the stage so really
 635         // this case should never happen
 636         task = list.CreateTask();
 637         start++;
 638       }
 639
 640       TreeNode::ConstIterator iter = (*renderTask).CBegin();
 641       task = list.GetTask( start - 1 );
 642
 643       SetupTask( task, (*iter).second, constant  );
 644
 645       ++iter;
 646
 647       for(; iter != (*renderTask).CEnd(); ++iter )
 648       {
 649         task = list.CreateTask();
 650         SetupTask( task, (*iter).second, constant );
 651       }
 652     }
 653   }
 654 }
 655
 656 ShaderEffect Builder::GetShaderEffect( const std::string &name)
 657 {
 658   Replacement constant( mReplacementMap );
 659   return GetShaderEffect( name, constant );
 660 }
 661
 662 ShaderEffect Builder::GetShaderEffect( const std::string &name, const Replacement& constant )
 663 {
 664   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 665
 666   ShaderEffect ret;
 667
 668   ShaderEffectLut::const_iterator iter( mShaderEffectLut.find( name ) );
 669   if( iter != mShaderEffectLut.end() )
 670   {
 671     ret = iter->second;
 672   }
 673   else
 674   {
 675     if( OptionalChild effects = IsChild( *mParser.GetRoot(), "shaderEffects") )
 676     {
 677       if( OptionalChild effect = IsChild( *effects, name ) )
 678       {
 679         Dali::Property::Value propertyMap(Property::MAP);
 680         if( SetPropertyFromNode( *effect, Property::MAP, propertyMap, constant ) )
 681         {
 682           ret = Dali::Scripting::NewShaderEffect( propertyMap );
 683           mShaderEffectLut[ name ] = ret;
 684         }
 685       }
 686     }
 687   }
 688
 689   return ret;
 690 }
 691
 692 FrameBufferImage Builder::GetFrameBufferImage( const std::string &name )
 693 {
 694   Replacement constant( mReplacementMap );
 695   return GetFrameBufferImage(name, constant);
 696 }
 697
 698 FrameBufferImage Builder::GetFrameBufferImage( const std::string &name, const Replacement& constant )
 699 {
 700   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 701
 702   FrameBufferImage ret;
 703
 704   ImageLut::const_iterator iter( mFrameBufferImageLut.find( name ) );
 705   if( iter != mFrameBufferImageLut.end() )
 706   {
 707     ret = iter->second;
 708   }
 709   else
 710   {
 711     if( OptionalChild images = IsChild( *mParser.GetRoot(), "frameBufferImages") )
 712     {
 713       if( OptionalChild image = IsChild( *images, name ) )
 714       {
 715         Dali::Property::Value property(Property::MAP);
 716         if( SetPropertyFromNode( *image, Property::MAP, property, constant ) )
 717         {
 718           Property::Map* map = property.GetMap();
 719
 720           if( map )
 721           {
 722             (*map)[ KEYNAME_TYPE ] = Property::Value(std::string("FrameBufferImage") );
 723             ret = FrameBufferImage::DownCast( Dali::Scripting::NewImage( property ) );
 724             mFrameBufferImageLut[ name ] = ret;
 725           }
 726         }
 727       }
 728     }
 729   }
 730
 731   return ret;
 732 }
 733
 734 Path Builder::GetPath( const std::string& name )
 735 {
 736   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 737
 738   Path ret;
 739
 740   PathLut::const_iterator iter( mPathLut.find( name ) );
 741   if( iter != mPathLut.end() )
 742   {
 743     ret = iter->second;
 744   }
 745   else
 746   {
 747     if( OptionalChild paths = IsChild( *mParser.GetRoot(), "paths") )
 748     {
 749       if( OptionalChild path = IsChild( *paths, name ) )
 750       {
 751         //points property
 752         if( OptionalChild pointsProperty = IsChild( *path, "points") )
 753         {
 754           Dali::Property::Value points(Property::ARRAY);
 755           if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 756           {
 757             ret = Path::New();
 758             ret.SetProperty( Path::Property::POINTS, points);
 759
 760             //controlPoints property
 761             if( OptionalChild pointsProperty = IsChild( *path, "controlPoints") )
 762             {
 763               Dali::Property::Value points(Property::ARRAY);
 764               if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 765               {
 766                 ret.SetProperty( Path::Property::CONTROL_POINTS, points);
 767               }
 768             }
 769             else
 770             {
 771               //Curvature
 772               float curvature(0.25f);
 773               if( OptionalFloat pointsProperty = IsFloat( *path, "curvature") )
 774               {
 775                 curvature = *pointsProperty;
 776               }
 777               ret.GenerateControlPoints(curvature);
 778             }
 779
 780             //Add the new path to the hash table for paths
 781             mPathLut[ name ] = ret;
 782           }
 783         }
 784         else
 785         {
 786           //Interpolation points not specified
 787           DALI_SCRIPT_WARNING("Interpolation points not specified for path '%s'\n", name.c_str() );
 788         }
 789       }
 790
 791     }
 792   }
 793
 794   return ret;
 795 }
 796
 797 PathConstrainer Builder::GetPathConstrainer( const std::string& name )
 798 {
 799   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 800
 801   //Search the pathConstrainer in the LUT
 802   size_t count( mPathConstrainerLut.size() );
 803   for( size_t i(0); i!=count; ++i )
 804   {
 805     if( mPathConstrainerLut[i].name == name )
 806     {
 807       //PathConstrainer has already been created
 808       return mPathConstrainerLut[i].pathConstrainer;
 809     }
 810   }
 811
 812   //Create a new PathConstrainer
 813   PathConstrainer ret;
 814   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 815   {
 816     if( OptionalChild pathConstrainer = IsChild( *constrainers, name ) )
 817     {
 818       OptionalString constrainerType(IsString(IsChild(*pathConstrainer, "type")));
 819       if(!constrainerType)
 820       {
 821         DALI_SCRIPT_WARNING("Constrainer type not specified for constrainer '%s'\n", name.c_str() );
 822       }
 823       else if( *constrainerType == "PathConstrainer")
 824       {
 825         //points property
 826         if( OptionalChild pointsProperty = IsChild( *pathConstrainer, "points") )
 827         {
 828           Dali::Property::Value points(Property::ARRAY);
 829           if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 830           {
 831             ret = PathConstrainer::New();
 832             ret.SetProperty( PathConstrainer::Property::POINTS, points);
 833
 834             //controlPoints property
 835             if( OptionalChild pointsProperty = IsChild( *pathConstrainer, "controlPoints") )
 836             {
 837               Dali::Property::Value points(Property::ARRAY);
 838               if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 839               {
 840                 ret.SetProperty( PathConstrainer::Property::CONTROL_POINTS, points);
 841               }
 842
 843               //Forward vector
 844               OptionalVector3 forward( IsVector3( IsChild(*pathConstrainer, "forward" ) ) );
 845               if( forward )
 846               {
 847                 ret.SetProperty( PathConstrainer::Property::FORWARD, *forward);
 848               }
 849
 850               //Add the new constrainer to the vector of PathConstrainer
 851               PathConstrainerEntry entry = {name,ret};
 852               mPathConstrainerLut.push_back( entry );
 853             }
 854             else
 855             {
 856               //Control points not specified
 857               DALI_SCRIPT_WARNING("Control points not specified for pathConstrainer '%s'\n", name.c_str() );
 858             }
 859           }
 860         }
 861         else
 862         {
 863           //Interpolation points not specified
 864           DALI_SCRIPT_WARNING("Interpolation points not specified for pathConstrainer '%s'\n", name.c_str() );
 865         }
 866       }
 867       else
 868       {
 869         DALI_SCRIPT_WARNING("Constrainer '%s' is not a PathConstrainer\n", name.c_str() );
 870       }
 871     }
 872   }
 873
 874   return ret;
 875 }
 876
 877 bool Builder::IsPathConstrainer( const std::string& name )
 878 {
 879   size_t count( mPathConstrainerLut.size() );
 880   for( size_t i(0); i!=count; ++i )
 881   {
 882     if( mPathConstrainerLut[i].name == name )
 883     {
 884       return true;
 885     }
 886   }
 887
 888   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 889   {
 890     if( OptionalChild constrainer = IsChild( *constrainers, name ) )
 891     {
 892       OptionalString constrainerType(IsString(IsChild(*constrainer, "type")));
 893       if(!constrainerType)
 894       {
 895         return false;
 896       }
 897       else
 898       {
 899          return *constrainerType == "PathConstrainer";
 900       }
 901     }
 902   }
 903   return false;
 904 }
 905
 906 Dali::LinearConstrainer Builder::GetLinearConstrainer( const std::string& name )
 907 {
 908   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
 909
 910   //Search the LinearConstrainer in the LUT
 911   size_t count( mLinearConstrainerLut.size() );
 912   for( size_t i(0); i!=count; ++i )
 913   {
 914     if( mLinearConstrainerLut[i].name == name )
 915     {
 916       //LinearConstrainer has already been created
 917       return mLinearConstrainerLut[i].linearConstrainer;
 918     }
 919   }
 920
 921   //Create a new LinearConstrainer
 922   LinearConstrainer ret;
 923   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 924   {
 925     if( OptionalChild linearConstrainer = IsChild( *constrainers, name ) )
 926     {
 927       OptionalString constrainerType(IsString(IsChild(*linearConstrainer, "type")));
 928       if(!constrainerType)
 929       {
 930         DALI_SCRIPT_WARNING("Constrainer type not specified for constrainer '%s'\n", name.c_str() );
 931       }
 932       else if( *constrainerType == "LinearConstrainer")
 933       {
 934         //points property
 935         if( OptionalChild pointsProperty = IsChild( *linearConstrainer, "value") )
 936         {
 937           Dali::Property::Value points(Property::ARRAY);
 938           if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 939           {
 940             ret = Dali::LinearConstrainer::New();
 941             ret.SetProperty( LinearConstrainer::Property::VALUE, points);
 942
 943             //controlPoints property
 944             if( OptionalChild pointsProperty = IsChild( *linearConstrainer, "progress") )
 945             {
 946               Dali::Property::Value points(Property::ARRAY);
 947               if( SetPropertyFromNode( *pointsProperty, Property::ARRAY, points ) )
 948               {
 949                 ret.SetProperty( LinearConstrainer::Property::PROGRESS, points);
 950               }
 951             }
 952             //Add the new constrainer to vector of LinearConstrainer
 953             LinearConstrainerEntry entry = {name,ret};
 954             mLinearConstrainerLut.push_back( entry );
 955           }
 956         }
 957         else
 958         {
 959           //Interpolation points not specified
 960           DALI_SCRIPT_WARNING("Values not specified for LinearConstrainer '%s'\n", name.c_str() );
 961         }
 962       }
 963       else
 964       {
 965         DALI_SCRIPT_WARNING("Constrainer '%s' is not a LinearConstrainer\n", name.c_str() );
 966       }
 967     }
 968   }
 969
 970   return ret;
 971 }
 972
 973 bool Builder::IsLinearConstrainer( const std::string& name )
 974 {
 975   //Search the LinearConstrainer in the LUT
 976   size_t count( mLinearConstrainerLut.size() );
 977   for( size_t i(0); i!=count; ++i )
 978   {
 979     if( mLinearConstrainerLut[i].name == name )
 980     {
 981       return true;
 982     }
 983   }
 984
 985   if( OptionalChild constrainers = IsChild( *mParser.GetRoot(), "constrainers") )
 986   {
 987     if( OptionalChild constrainer = IsChild( *constrainers, name ) )
 988     {
 989       OptionalString constrainerType(IsString(IsChild(*constrainer, "type")));
 990       if(!constrainerType)
 991       {
 992         return false;
 993       }
 994       else
 995       {
 996          return *constrainerType == "LinearConstrainer";
 997       }
 998     }
 999   }
1000   return false;
1001 }
1002
1003 Toolkit::Builder::BuilderSignalType& Builder::QuitSignal()
1004 {
1005   return mQuitSignal;
1006 }
1007
1008 void Builder::EmitQuitSignal()
1009 {
1010   mQuitSignal.Emit();
1011 }
1012
1013 void Builder::AddActors( Actor toActor )
1014 {
1015   // 'stage' is the default/by convention section to add from
1016   AddActors( "stage", toActor );
1017 }
1018
1019 void Builder::AddActors( const std::string &sectionName, Actor toActor )
1020 {
1021   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1022
1023   Property::Map overrideMap;
1024   Replacement replacements(overrideMap, mReplacementMap);
1025
1026   OptionalChild add = IsChild(*mParser.GetRoot(), sectionName);
1027
1028   if( add )
1029   {
1030     for( TreeNode::ConstIterator iter = (*add).CBegin(); iter != (*add).CEnd(); ++iter )
1031     {
1032       // empty actor adds directly to the stage
1033       BaseHandle baseHandle = DoCreate( *mParser.GetRoot(), (*iter).second, Actor(), replacements );
1034       Actor actor = Actor::DownCast(baseHandle);
1035       if(actor)
1036       {
1037         toActor.Add( actor );
1038       }
1039     }
1040
1041     // if were adding the 'stage' section then also check for a render task called stage
1042     // to add automatically
1043     if( "stage" == sectionName )
1044     {
1045       if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "renderTasks") )
1046       {
1047         if( OptionalChild tasks = IsChild(*renderTasks, "stage") )
1048         {
1049           CreateRenderTask( "stage" );
1050         }
1051       }
1052     }
1053   }
1054 }
1055
1056 Animation Builder::CreateAnimation( const std::string& animationName, const Replacement& replacement, Dali::Actor sourceActor )
1057 {
1058   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1059
1060   Animation anim;
1061
1062   if( OptionalChild animations = IsChild(*mParser.GetRoot(), "animations") )
1063   {
1064     if( OptionalChild animation = IsChild(*animations, animationName) )
1065     {
1066       anim = Dali::Toolkit::Internal::CreateAnimation( *animation, replacement, sourceActor, this );
1067     }
1068     else
1069     {
1070       DALI_SCRIPT_WARNING( "Request for Animation called '%s' failed\n", animationName.c_str() );
1071     }
1072   }
1073   else
1074   {
1075     DALI_SCRIPT_WARNING( "Request for Animation called '%s' failed (no animation section)\n", animationName.c_str() );
1076   }
1077
1078   return anim;
1079 }
1080
1081 Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map, Dali::Actor sourceActor )
1082 {
1083   Replacement replacement(map, mReplacementMap);
1084   return CreateAnimation( animationName, replacement, sourceActor);
1085 }
1086
1087 Animation Builder::CreateAnimation( const std::string& animationName, const Property::Map& map )
1088 {
1089   Replacement replacement(map, mReplacementMap);
1090   return CreateAnimation( animationName, replacement, Stage::GetCurrent().GetRootLayer() );
1091 }
1092
1093 Animation Builder::CreateAnimation( const std::string& animationName, Dali::Actor sourceActor )
1094 {
1095   Replacement replacement( mReplacementMap );
1096
1097   return CreateAnimation( animationName, replacement, sourceActor );
1098 }
1099
1100 Animation Builder::CreateAnimation( const std::string& animationName )
1101 {
1102   Replacement replacement( mReplacementMap );
1103
1104   return CreateAnimation( animationName, replacement, Dali::Stage::GetCurrent().GetRootLayer() );
1105 }
1106
1107 void Builder::LoadFromString( std::string const& data, Dali::Toolkit::Builder::UIFormat format )
1108 {
1109   // parser to get constants and includes only
1110   Dali::Toolkit::JsonParser parser = Dali::Toolkit::JsonParser::New();
1111
1112   if( !parser.Parse( data ) )
1113   {
1114     DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
1115                       parser.GetErrorLineNumber(),
1116                       parser.GetErrorColumn(),
1117                       parser.GetErrorDescription().c_str() );
1118
1119     DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
1120
1121   }
1122   else
1123   {
1124     // load constant map (allows the user to override the constants in the json after loading)
1125     LoadConstants( *parser.GetRoot(), mReplacementMap );
1126
1127     // merge includes
1128     if( OptionalChild includes = IsChild(*parser.GetRoot(), KEYNAME_INCLUDES) )
1129     {
1130       Replacement replacer( mReplacementMap );
1131
1132       for(TreeNode::ConstIterator iter = (*includes).CBegin(); iter != (*includes).CEnd(); ++iter)
1133       {
1134         OptionalString filename = replacer.IsString( (*iter).second );
1135
1136         if( filename )
1137         {
1138 #if defined(DEBUG_ENABLED)
1139           DALI_SCRIPT_VERBOSE("Loading Include '%s'\n", (*filename).c_str());
1140 #endif
1141           LoadFromString( GetFileContents(*filename) );
1142         }
1143       }
1144     }
1145
1146     if( !mParser.Parse( data ) )
1147     {
1148       DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
1149                         mParser.GetErrorLineNumber(),
1150                         mParser.GetErrorColumn(),
1151                         mParser.GetErrorDescription().c_str() );
1152
1153       DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
1154     }
1155   }
1156
1157   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Cannot parse JSON");
1158
1159 }
1160
1161 void Builder::AddConstants( const Property::Map& map )
1162 {
1163   mReplacementMap.Merge( map );
1164 }
1165
1166 void Builder::AddConstant( const std::string& key, const Property::Value& value )
1167 {
1168   mReplacementMap[key] = value;
1169 }
1170
1171 const Property::Map& Builder::GetConstants() const
1172 {
1173   return mReplacementMap;
1174 }
1175
1176 const Property::Value& Builder::GetConstant( const std::string& key ) const
1177 {
1178   Property::Value* match = mReplacementMap.Find( key );
1179   if( match )
1180   {
1181     return (*match);
1182   }
1183   else
1184   {
1185     static Property::Value invalid;
1186     return invalid;
1187   }
1188 }
1189
1190 void Builder::LoadConstants( const TreeNode& root, Property::Map& intoMap )
1191 {
1192   Replacement replacer(intoMap);
1193
1194   if( OptionalChild constants = IsChild(root, "constants") )
1195   {
1196     for(TreeNode::ConstIterator iter = (*constants).CBegin();
1197         iter != (*constants).CEnd(); ++iter)
1198     {
1199       Dali::Property::Value property;
1200       if( (*iter).second.GetName() )
1201       {
1202 #if defined(DEBUG_ENABLED)
1203         DALI_SCRIPT_VERBOSE("Constant set from json '%s'\n", (*iter).second.GetName());
1204 #endif
1205         if( SetPropertyFromNode( (*iter).second, property, replacer ) )
1206         {
1207           intoMap[ (*iter).second.GetName() ] = property;
1208         }
1209         else
1210         {
1211           DALI_SCRIPT_WARNING("Cannot convert property for constant %s\n",
1212                               (*iter).second.GetName() == NULL ? "no name?" : (*iter).second.GetName());
1213         }
1214       }
1215     }
1216   }
1217
1218 #if defined(DEBUG_ENABLED)
1219   Property::Value* iter = intoMap.Find( "CONFIG_SCRIPT_LOG_LEVEL" );
1220   if( iter && iter->GetType() == Property::STRING )
1221   {
1222     std::string logLevel( iter->Get< std::string >() );
1223     if( logLevel == "NoLogging" )
1224     {
1225       gFilterScript->SetLogLevel( Integration::Log::NoLogging );
1226     }
1227     else if( logLevel == "Concise" )
1228     {
1229       gFilterScript->SetLogLevel( Integration::Log::Concise );
1230     }
1231     else if( logLevel == "General" )
1232     {
1233       gFilterScript->SetLogLevel( Integration::Log::General );
1234     }
1235     else if( logLevel == "Verbose" )
1236     {
1237       gFilterScript->SetLogLevel( Integration::Log::Verbose );
1238     }
1239   }
1240 #endif
1241
1242 }
1243
1244 bool Builder::ApplyStyle( const std::string& styleName, Handle& handle )
1245 {
1246   Replacement replacer( mReplacementMap );
1247   return ApplyStyle( styleName, handle, replacer );
1248 }
1249
1250 bool Builder::ApplyStyle( const std::string& styleName, Handle& handle, const Replacement& replacement )
1251 {
1252   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1253
1254   OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
1255   OptionalChild style  = IsChild( *styles, styleName );
1256
1257   if( styles && style )
1258   {
1259     ApplyAllStyleProperties( *mParser.GetRoot(), *style, handle, replacement );
1260     return true;
1261   }
1262   else
1263   {
1264     return false;
1265   }
1266 }
1267
1268 BaseHandle Builder::Create( const std::string& templateName, const Property::Map& map )
1269 {
1270   Replacement replacement( map, mReplacementMap );
1271   return Create( templateName, replacement );
1272 }
1273
1274 BaseHandle Builder::Create( const std::string& templateName, const Replacement& constant )
1275 {
1276   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1277
1278   BaseHandle baseHandle;
1279
1280   OptionalChild templates = IsChild(*mParser.GetRoot(), KEYNAME_TEMPLATES);
1281
1282   if( !templates )
1283   {
1284     DALI_SCRIPT_WARNING("No template section found to CreateFromTemplate\n");
1285   }
1286   else
1287   {
1288     OptionalChild childTemplate = IsChild(*templates, templateName);
1289     if(!childTemplate)
1290     {
1291       DALI_SCRIPT_WARNING("Template '%s' does not exist in template section\n", templateName.c_str());
1292     }
1293     else
1294     {
1295       OptionalString type = constant.IsString( IsChild(*childTemplate, KEYNAME_TYPE) );
1296
1297       if(!type)
1298       {
1299         DALI_SCRIPT_WARNING("Cannot create template '%s' as template section is missing 'type'\n", templateName.c_str());
1300       }
1301       else
1302       {
1303         baseHandle = DoCreate( *mParser.GetRoot(), *childTemplate, Actor(), constant );
1304       }
1305     }
1306   }
1307
1308   return baseHandle;
1309 }
1310
1311 BaseHandle Builder::CreateFromJson( const std::string& json )
1312 {
1313   BaseHandle ret;
1314
1315   // merge in new template, hoping no one else has one named '@temp@'
1316   std::string newTemplate =
1317     std::string("{\"templates\":{\"@temp@\":") +                      \
1318     json +                                                            \
1319     std::string("}}");
1320
1321   if( mParser.Parse(newTemplate) )
1322   {
1323     Replacement replacement( mReplacementMap );
1324     ret = Create( "@temp@", replacement );
1325   }
1326
1327   return ret;
1328 }
1329
1330 bool Builder::ApplyFromJson(  Handle& handle, const std::string& json )
1331 {
1332   bool ret = false;
1333
1334   // merge new style, hoping no one else has one named '@temp@'
1335   std::string newStyle =
1336     std::string("{\"styles\":{\"@temp@\":") +                           \
1337     json +                                                              \
1338     std::string("}}");
1339
1340   if( mParser.Parse(newStyle) )
1341   {
1342     Replacement replacement( mReplacementMap );
1343     ret = ApplyStyle( "@temp@", handle, replacement );
1344   }
1345
1346   return ret;
1347 }
1348
1349
1350 BaseHandle Builder::Create( const std::string& templateName )
1351 {
1352   Replacement replacement( mReplacementMap );
1353   return Create( templateName, replacement );
1354 }
1355
1356 Builder::Builder()
1357 : mSlotDelegate( this )
1358 {
1359   mParser = Dali::Toolkit::JsonParser::New();
1360
1361   Property::Map defaultDirs;
1362   defaultDirs[ TOKEN_STRING(DALI_IMAGE_DIR) ]  = DALI_IMAGE_DIR;
1363   defaultDirs[ TOKEN_STRING(DALI_SOUND_DIR) ]  = DALI_SOUND_DIR;
1364   defaultDirs[ TOKEN_STRING(DALI_STYLE_DIR) ] = DALI_STYLE_DIR;
1365   defaultDirs[ TOKEN_STRING(DALI_STYLE_IMAGE_DIR) ] = DALI_STYLE_IMAGE_DIR;
1366
1367   AddConstants( defaultDirs );
1368 }
1369
1370 Builder::~Builder()
1371 {
1372 }
1373
1374 } // namespace Internal
1375
1376 } // namespace Toolkit
1377
1378 } // namespace Dali