(StyleManager) Remove StyleManager header include form CAPI
[platform/core/uifw/dali-toolkit.git] / base / dali-toolkit / internal / builder / builder-impl.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
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 // CLASS HEADER
18 #include <dali-toolkit/internal/builder/builder-impl.h>
19
20 // EXTERNAL INCLUDES
21 #include <sys/stat.h>
22
23 // INTERNAL INCLUDES
24 #include <dali/dali.h>
25 #include <dali/integration-api/debug.h>
26
27 #include <dali-toolkit/public-api/controls/control.h>
28 #include <dali-toolkit/public-api/builder/json-parser.h>
29
30 #include <dali-toolkit/internal/builder/builder-get-is.inl.h>
31 #include <dali-toolkit/internal/builder/builder-filesystem.h>
32 #include <dali-toolkit/internal/builder/builder-declarations.h>
33 #include <dali-toolkit/internal/builder/replacement.h>
34
35 namespace Dali
36 {
37
38 namespace Toolkit
39 {
40
41 namespace Internal
42 {
43 class Replacement;
44
45 extern Animation CreateAnimation(const TreeNode& child, const Replacement& replacements, const Dali::Actor searchRoot );
46 extern bool SetPropertyFromNode( const TreeNode& node, Property::Value& value );
47 extern bool SetPropertyFromNode( const TreeNode& node, Property::Value& value, const Replacement& replacements );
48 extern bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value );
49 extern bool SetPropertyFromNode( const TreeNode& node, Property::Type type, Property::Value& value, const Replacement& replacements );
50 extern Actor SetupSignalAction(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor);
51 extern Actor SetupPropertyNotification(ConnectionTracker* tracker, const TreeNode &root, const TreeNode &child, Actor actor);
52 extern Actor SetupActor( const TreeNode& node, Actor& actor );
53
54 #if defined(DEBUG_ENABLED)
55 Integration::Log::Filter* gFilterScript  = Integration::Log::Filter::New(Debug::NoLogging, false, "LOG_SCRIPT");
56 #endif
57
58 namespace
59 {
60
61 const std::string KEYNAME_STYLES    = "styles";
62 const std::string KEYNAME_TYPE      = "type";
63 const std::string KEYNAME_ACTORS    = "actors";
64 const std::string KEYNAME_SIGNALS   = "signals";
65 const std::string KEYNAME_NAME      = "name";
66 const std::string KEYNAME_TEMPLATES = "templates";
67 const std::string KEYNAME_INCLUDES  = "includes";
68
69 typedef std::vector<const TreeNode*> TreeNodeList;
70
71 template <typename T>
72 std::string ToString(const T& value)
73 {
74   std::stringstream ss;
75   ss << value;
76   return ss.str();
77 }
78
79 template <>
80 std::string ToString(const Rect<int>& value)
81 {
82   std::stringstream ss;
83   ss << value.x << "," << value.y << "," << value.width << "," << value.height;
84   return ss.str();
85 }
86
87
88 std::string PropertyValueToString( const Property::Value& value )
89 {
90   std::string ret;
91
92   switch( value.GetType() )
93   {
94     case Property::NONE:
95     {
96       ret = "NONE";
97       break;
98     }            ///< No type
99     case Property::BOOLEAN:
100     {
101       ret = value.Get<bool>() ? "True" : "False";
102       break;
103     }
104     case Property::FLOAT:
105     {
106
107       ret = ToString( value.Get<float>() );
108       break;
109     }
110     case Property::INTEGER:
111     {
112       ret = ToString( value.Get<int>() );
113       break;
114     }
115     case Property::UNSIGNED_INTEGER:
116     {
117       ret = ToString( value.Get<unsigned int>() );
118       break;
119     }
120     case Property::VECTOR2:
121     {
122       ret = ToString( value.Get<Vector2>() );
123       break;
124     }
125     case Property::VECTOR3:
126     {
127       ret = ToString( value.Get<Vector3>() );
128       break;
129     }
130     case Property::VECTOR4:
131     {
132       ret = ToString( value.Get<Vector4>() );
133       break;
134     }
135     case Property::MATRIX3:
136     {
137       ret = ToString( value.Get<Matrix3>() );
138       break;
139     }
140     case Property::MATRIX:
141     {
142       ret = ToString( value.Get<Matrix>() );
143       break;
144     }
145     case Property::RECTANGLE:
146     {
147       ret = ToString( value.Get< Rect<int> >() );
148       break;
149     }
150     case Property::ROTATION:
151     {
152       break;
153     }
154     case Property::STRING:
155     {
156       ret = value.Get<std::string>();
157       break;
158     }
159     case Property::ARRAY:
160     {
161       ret = std::string("Array Size=") + ToString( value.Get<Property::Array>().size() );
162       break;
163     }
164     case Property::MAP:
165     {
166       ret = std::string("Map Size=") + ToString( value.Get<Property::Map>().size() );
167       break;
168     }
169     case Property::TYPE_COUNT:
170     {
171       ret = "";
172       break;
173     }
174   }
175
176   return ret;
177 }
178
179 /*
180  * Recursively collects all stylesin a node (An array of style names).
181  *
182  * stylesCollection The set of styles from the json file (a json object of named styles)
183  * style The style array to begin the collection from
184  * styleList The style list to add nodes to apply
185  */
186 void CollectAllStyles( const TreeNode& stylesCollection, const TreeNode& style, TreeNodeList& styleList )
187 {
188   // style is an array of style names
189   if( TreeNode::ARRAY == style.GetType() )
190   {
191     for(TreeNode::ConstIterator iter = style.CBegin(); iter != style.CEnd(); ++iter)
192     {
193       if( OptionalString styleName = IsString( (*iter).second ) )
194       {
195         if( OptionalChild node = IsChild( stylesCollection, *styleName) )
196         {
197           styleList.push_back( &(*node) );
198
199           if( OptionalChild subStyle = IsChild( *node, KEYNAME_STYLES ) )
200           {
201             CollectAllStyles( stylesCollection, *subStyle, styleList );
202           }
203         }
204       }
205     }
206   }
207 }
208
209 } // namespace anon
210
211 /*
212  * Sets the handle properties found in the tree node
213  */
214 void Builder::SetProperties( const TreeNode& node, Handle& handle, const Replacement& constant )
215 {
216   if( handle )
217   {
218     for( TreeNode::ConstIterator iter = node.CBegin(); iter != node.CEnd(); ++iter )
219     {
220       const TreeNode::KeyNodePair& keyChild = *iter;
221
222       std::string key( keyChild.first );
223
224       // ignore special fields; type,actors,signals
225       if(key == KEYNAME_TYPE || key == KEYNAME_ACTORS || key == KEYNAME_SIGNALS || key == KEYNAME_STYLES)
226       {
227         continue;
228       }
229
230       // special field 'image' usually contains an json object description
231       // although sometimes refers to a framebuffer
232       if( 0 == keyChild.second.Size() )
233       {
234         if(key == "image")
235         {
236           ImageActor imageActor = ImageActor::DownCast(handle);
237           if(imageActor)
238           {
239             if( OptionalString s = constant.IsString( keyChild.second ) )
240             {
241               FrameBufferImage fb = GetFrameBufferImage(*s, constant);
242               if(fb)
243               {
244                 imageActor.SetImage( fb );
245               }
246             }
247           }
248         }
249       }
250
251       // special field 'effect' references the shader effect instances
252       if(key == "effect")
253       {
254         Actor actor = Actor::DownCast(handle);
255         OptionalString s = constant.IsString( keyChild.second );
256         if(actor && s)
257         {
258           ShaderEffect e = GetShaderEffect(*s, constant);
259           actor.SetShaderEffect(e);
260         }
261         else
262         {
263           DALI_SCRIPT_WARNING("Could not find or set shader effect\n");
264         }
265
266         continue;
267       }
268
269       Handle propertyObject( handle );
270
271       Property::Index index = propertyObject.GetPropertyIndex( key );
272
273       if( Property::INVALID_INDEX == index )
274       {
275         Actor actor = Actor::DownCast(propertyObject);
276         if( actor )
277         {
278           if( ShaderEffect effect = actor.GetShaderEffect() )
279           {
280             index = effect.GetPropertyIndex( key );
281             if(index != Property::INVALID_INDEX)
282             {
283               propertyObject = effect;
284             }
285           }
286         }
287       }
288
289       if( Property::INVALID_INDEX != index )
290       {
291         Property::Type type = propertyObject.GetPropertyType(index);
292
293         Property::Value value;
294         if( !SetPropertyFromNode( keyChild.second, type, value, constant ) )
295         {
296           // verbose as this might not be a problem
297           // eg parent-origin can be a string which is picked up later
298           DALI_SCRIPT_VERBOSE("Could not convert property:%s\n", key.c_str());
299         }
300         else
301         {
302           DALI_SCRIPT_VERBOSE("SetProperty '%s' Index=:%d Value Type=%d Value '%s'\n", key.c_str(), index, value.GetType(), PropertyValueToString(value).c_str() );
303
304           propertyObject.SetProperty( index, value );
305         }
306       }
307       else
308       {
309         DALI_SCRIPT_VERBOSE("SetProperty INVALID '%s' Index=:%d\n", key.c_str(), index);
310       }
311
312     } // for property nodes
313   }
314   else
315   {
316     DALI_SCRIPT_WARNING("Style applied to empty handle\n");
317   }
318 }
319
320 // Set properties from node on handle.
321 void Builder::ApplyProperties( const TreeNode& root, const TreeNode& node,
322                                Dali::Handle& handle, const Replacement& constant )
323 {
324   if( Actor actor = Actor::DownCast(handle) )
325   {
326     SetProperties( node, actor, constant );
327
328     if( actor )
329     {
330       SetupActor( node, actor );
331
332       // add signals
333       SetupSignalAction( mSlotDelegate.GetConnectionTracker(), root, node, actor );
334
335       SetupPropertyNotification( mSlotDelegate.GetConnectionTracker(), root, node, actor );
336    }
337   }
338   else
339   {
340     SetProperties( node, handle, constant );
341   }
342 }
343
344 // Appling by style helper
345 // use FindChildByName() to apply properties referenced in KEYNAME_ACTORS in the node
346 void Builder::ApplyStylesByActor(  const TreeNode& root, const TreeNode& node,
347                                    Dali::Handle& handle, const Replacement& constant )
348 {
349   if( Dali::Actor actor = Dali::Actor::DownCast( handle ) )
350   {
351     if( const TreeNode* actors = node.GetChild( KEYNAME_ACTORS ) )
352     {
353       // in a style the actor subtree properties referenced by actor name
354       for( TreeConstIter iter = actors->CBegin(); iter != actors->CEnd(); ++iter )
355       {
356         Dali::Actor foundActor;
357
358         if( (*iter).first )
359         {
360           foundActor = actor.FindChildByName( (*iter).first );
361         }
362
363         if( !foundActor )
364         {
365           // debug log cannot find searched for actor
366 #if defined(DEBUG_ENABLED)
367           DALI_SCRIPT_VERBOSE("Cannot find actor in style application '%s'\n", (*iter).first);
368 #endif
369         }
370         else
371         {
372 #if defined(DEBUG_ENABLED)
373           DALI_SCRIPT_VERBOSE("Styles applied to actor '%s'\n", (*iter).first);
374 #endif
375           ApplyProperties( root, (*iter).second, foundActor, constant );
376         }
377       }
378     }
379   }
380 }
381
382
383 void Builder::ApplyAllStyleProperties( const TreeNode& root, const TreeNode& node,
384                                        Dali::Handle& handle, const Replacement& constant )
385 {
386   OptionalChild styles = IsChild(root, KEYNAME_STYLES);
387   OptionalChild style  = IsChild(node, KEYNAME_STYLES);
388
389   if( styles && style )
390   {
391     TreeNodeList additionalStyles;
392
393     CollectAllStyles( *styles, *style, additionalStyles );
394
395 #if defined(DEBUG_ENABLED)
396     for(TreeNode::ConstIterator iter = (*style).CBegin(); iter != (*style).CEnd(); ++iter)
397     {
398       if( OptionalString styleName = IsString( (*iter).second ) )
399       {
400         DALI_SCRIPT_VERBOSE("Style Applied '%s'\n", (*styleName).c_str());
401       }
402     }
403 #endif
404
405     // a style may have other styles, which has other styles etc so we apply in reverse by convention.
406     for(TreeNodeList::reverse_iterator iter = additionalStyles.rbegin(); iter != additionalStyles.rend(); ++iter)
407     {
408       ApplyProperties( root, *(*iter), handle, constant );
409
410       ApplyStylesByActor( root, *(*iter), handle, constant );
411     }
412   }
413
414   // applying given node last
415   ApplyProperties( root, node, handle, constant );
416
417   ApplyStylesByActor( root, node, handle, constant );
418
419 }
420
421
422 /*
423  * Create a dali type from a node.
424  * If parent given and an actor type was created then add it to the parent and
425  * recursively add nodes children.
426  */
427 BaseHandle Builder::DoCreate( const TreeNode& root, const TreeNode& node,
428                               Actor parent, const Replacement& replacements )
429 {
430   BaseHandle baseHandle;
431   TypeInfo typeInfo;
432   const TreeNode* templateNode = NULL;
433
434   if( OptionalString typeName = IsString(node, KEYNAME_TYPE) )
435   {
436     typeInfo = TypeRegistry::Get().GetTypeInfo( *typeName );
437
438     if( !typeInfo )
439     {
440       // a template name is also allowed inplace of the type name
441       OptionalChild templates = IsChild( root, KEYNAME_TEMPLATES);
442
443       if( templates )
444       {
445         if( OptionalChild isTemplate = IsChild( *templates, *typeName ) )
446         {
447           templateNode = &(*isTemplate);
448
449           if( OptionalString templateTypeName = IsString(*templateNode, KEYNAME_TYPE) )
450           {
451             typeInfo = TypeRegistry::Get().GetTypeInfo( *templateTypeName );
452           }
453         }
454       }
455     }
456   }
457
458   if(!typeInfo)
459   {
460     DALI_SCRIPT_WARNING("Cannot create Dali type from node '%s'\n", node.GetName());
461   }
462   else
463   {
464     baseHandle       = typeInfo.CreateInstance();
465     Handle handle    = Handle::DownCast(baseHandle);
466     Actor actor      = Actor::DownCast(handle);
467
468     if(handle)
469     {
470
471       DALI_SCRIPT_VERBOSE("Create:%s\n", typeInfo.GetName().c_str());
472
473 #if defined(DEBUG_ENABLED)
474       if(handle)
475       {
476         DALI_SCRIPT_VERBOSE("  Is Handle Object=%d\n", (long*)handle.GetObjectPtr());
477         DALI_SCRIPT_VERBOSE("  Is Handle Property Count=%d\n", handle.GetPropertyCount());
478       }
479
480       if(actor)
481       {
482         DALI_SCRIPT_VERBOSE("  Is Actor id=%d\n", actor.GetId());
483       }
484
485       Toolkit::Control control  = Toolkit::Control::DownCast(handle);
486       if(control)
487       {
488         DALI_SCRIPT_VERBOSE("  Is Control id=%d\n", actor.GetId());
489       }
490 #endif // DEBUG_ENABLED
491
492       if( templateNode )
493       {
494         ApplyProperties( root, *templateNode, handle, replacements );
495
496         if( OptionalChild actors = IsChild( *templateNode, KEYNAME_ACTORS ) )
497         {
498           for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
499           {
500             DoCreate( root, (*iter).second, actor, replacements );
501           }
502         }
503       }
504
505       ApplyProperties( root, node, handle, replacements );
506
507       if( actor)
508       {
509         // add children of all the styles
510         if( OptionalChild actors = IsChild( node, KEYNAME_ACTORS ) )
511         {
512           for( TreeConstIter iter = (*actors).CBegin(); iter != (*actors).CEnd(); ++iter )
513           {
514             DoCreate( root, (*iter).second, actor, replacements );
515           }
516         }
517
518         // apply style on top as they need the children to exist
519         ApplyAllStyleProperties( root, node, actor, replacements );
520
521         // then add to parent
522         if( parent )
523         {
524           parent.Add( actor );
525         }
526       }
527
528     }
529     else
530     {
531       DALI_SCRIPT_WARNING("Cannot create handle from type '%s'\n", typeInfo.GetName().c_str());
532     }
533   }
534
535   return baseHandle;
536 }
537
538
539 ActorContainer Builder::GetTopLevelActors() const
540 {
541   // deprecated function.
542   return ActorContainer();
543 }
544
545 Animation Builder::GetAnimation( const std::string &name ) const
546 {
547   // deprecated
548   return Animation();
549 }
550
551 void Builder::SetupTask( RenderTask& task, const TreeNode& node, const Replacement& constant )
552 {
553   const Stage& stage = Stage::GetCurrent();
554   Layer root  = stage.GetRootLayer();
555
556   if( OptionalString s = constant.IsString( IsChild(node, "source-actor") ) )
557   {
558     Actor actor = root.FindChildByName(*s);
559     if(actor)
560     {
561       task.SetSourceActor( actor );
562     }
563     else
564     {
565       DALI_SCRIPT_WARNING("Cannot find source actor on stage for render task called '%s'\n", (*s).c_str() );
566     }
567   }
568
569   if( OptionalString s = constant.IsString( IsChild(node, "camera-actor") ) )
570   {
571     CameraActor actor = CameraActor::DownCast( root.FindChildByName(*s) );
572     if(actor)
573     {
574       task.SetCameraActor( actor );
575     }
576     else
577     {
578       DALI_SCRIPT_WARNING("Cannot find camera actor on stage for render task called '%s'\n", (*s).c_str() );
579     }
580   }
581
582   if( OptionalString s = constant.IsString( IsChild(node, "target-frame-buffer") ) )
583   {
584     FrameBufferImage fb = GetFrameBufferImage( *s, constant );
585     if(fb)
586     {
587       task.SetTargetFrameBuffer( fb );
588     }
589     else
590     {
591       DALI_SCRIPT_WARNING("Cannot find target frame buffer '%s'\n", (*s).c_str() );
592     }
593   }
594
595   if( OptionalString s = constant.IsString( IsChild(node, "screen-to-frame-buffer-function") ) )
596   {
597     if("DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION" == *s)
598     {
599       task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
600     }
601     else if("FULLSCREEN_FRAMEBUFFER_FUNCTION" == *s)
602     {
603       task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
604     }
605     else
606     {
607       DALI_SCRIPT_WARNING("todo");
608     }
609   }
610
611   // other setup is via the property system
612   SetProperties( node, task, constant ); // @ todo, remove 'source-actor', 'camera-actor'?
613
614 }
615
616 void Builder::CreateRenderTask( const std::string &name )
617 {
618   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
619
620   Replacement constant(mReplacementMap);
621
622   const Stage& stage = Stage::GetCurrent();
623
624   OptionalChild tasks = IsChild(*mParser.GetRoot(), "render-tasks");
625
626   if(tasks)
627   {
628     //
629     // Create the tasks from the current task as generally we want
630     // to setup task zero and onwards. Although this does overwrite
631     // the properties of the current task.
632     //
633     if( OptionalChild renderTask = IsChild(*tasks, name ) )
634     {
635       RenderTaskList list = stage.GetRenderTaskList();
636       unsigned int start = list.GetTaskCount();
637
638       RenderTask task;
639       if(0 == start)
640       {
641         // zero should have already been created by the stage so really
642         // this case should never happen
643         task = list.CreateTask();
644         start++;
645       }
646
647       TreeNode::ConstIterator iter = (*renderTask).CBegin();
648       task = list.GetTask( start - 1 );
649
650       SetupTask( task, (*iter).second, constant  );
651
652       ++iter;
653
654       for(; iter != (*renderTask).CEnd(); ++iter )
655       {
656         task = list.CreateTask();
657         SetupTask( task, (*iter).second, constant );
658       }
659     }
660   }
661 }
662
663 ShaderEffect Builder::GetShaderEffect( const std::string &name)
664 {
665   Replacement constant( mReplacementMap );
666   return GetShaderEffect( name, constant );
667 }
668
669 ShaderEffect Builder::GetShaderEffect( const std::string &name, const Replacement& constant )
670 {
671   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
672
673   ShaderEffect ret;
674
675   ShaderEffectLut::const_iterator iter( mShaderEffectLut.find( name ) );
676   if( iter != mShaderEffectLut.end() )
677   {
678     ret = iter->second;
679   }
680   else
681   {
682     if( OptionalChild effects = IsChild( *mParser.GetRoot(), "shader-effects") )
683     {
684       if( OptionalChild effect = IsChild( *effects, name ) )
685       {
686         Dali::Property::Value propertyMap(Property::MAP);
687         if( SetPropertyFromNode( *effect, Property::MAP, propertyMap, constant ) )
688         {
689           ret = Dali::Scripting::NewShaderEffect( propertyMap );
690           mShaderEffectLut[ name ] = ret;
691         }
692       }
693     }
694   }
695
696   return ret;
697 }
698
699 FrameBufferImage Builder::GetFrameBufferImage( const std::string &name )
700 {
701   Replacement constant( mReplacementMap );
702   return GetFrameBufferImage(name, constant);
703 }
704
705 FrameBufferImage Builder::GetFrameBufferImage( const std::string &name, const Replacement& constant )
706 {
707   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
708
709   FrameBufferImage ret;
710
711   ImageLut::const_iterator iter( mFrameBufferImageLut.find( name ) );
712   if( iter != mFrameBufferImageLut.end() )
713   {
714     ret = iter->second;
715   }
716   else
717   {
718     if( OptionalChild images = IsChild( *mParser.GetRoot(), "frame-buffer-images") )
719     {
720       if( OptionalChild image = IsChild( *images, name ) )
721       {
722         Dali::Property::Value propertyMap(Property::MAP);
723         if( SetPropertyFromNode( *image, Property::MAP, propertyMap, constant ) )
724         {
725           propertyMap.SetValue(KEYNAME_TYPE, Property::Value(std::string("FrameBufferImage")));
726           ret = Dali::Scripting::NewImage( propertyMap );
727           mFrameBufferImageLut[ name ] = ret;
728         }
729       }
730     }
731   }
732
733   return ret;
734 }
735
736 Font Builder::GetFont( const std::string& name ) const
737 {
738   // deprecated function.
739   Font font;
740   return font;
741 }
742
743 TextStyle Builder::GetTextStyle( const std::string& name ) const
744 {
745   // deprecated
746   return TextStyle();
747 }
748
749 Image Builder::GetImage( const std::string& name) const
750 {
751   // deprecated function.
752   return Image();
753 }
754
755 Actor Builder::GetActor( const std::string &name ) const
756 {
757   // deprecated function.
758   return Actor();
759 }
760
761 void Builder::AddActors( Actor toActor )
762 {
763   // 'stage' is the default/by convention section to add from
764   AddActors( "stage", toActor );
765 }
766
767 void Builder::AddActors( const std::string &sectionName, Actor toActor )
768 {
769   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
770
771   PropertyValueMap overrideMap;
772   Replacement replacements(overrideMap, mReplacementMap);
773
774   OptionalChild add = IsChild(*mParser.GetRoot(), sectionName);
775
776   if( add )
777   {
778     for( TreeNode::ConstIterator iter = (*add).CBegin(); iter != (*add).CEnd(); ++iter )
779     {
780       // empty actor adds directly to the stage
781       BaseHandle baseHandle = DoCreate( *mParser.GetRoot(), (*iter).second, Actor(), replacements );
782       Actor actor = Actor::DownCast(baseHandle);
783       if(actor)
784       {
785         toActor.Add( actor );
786       }
787     }
788
789     // if were adding the 'stage' section then also check for a render task called stage
790     // to add automatically
791     if( "stage" == sectionName )
792     {
793       if( OptionalChild renderTasks = IsChild(*mParser.GetRoot(), "render-tasks") )
794       {
795         if( OptionalChild tasks = IsChild(*renderTasks, "stage") )
796         {
797           CreateRenderTask( "stage" );
798         }
799       }
800     }
801   }
802 }
803
804 Animation Builder::CreateAnimation( const std::string& animationName, const Replacement& replacement, Dali::Actor sourceActor )
805 {
806   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
807
808   Animation anim;
809
810   if( OptionalChild animations = IsChild(*mParser.GetRoot(), "animations") )
811   {
812     if( OptionalChild animation = IsChild(*animations, animationName) )
813     {
814       anim = Dali::Toolkit::Internal::CreateAnimation( *animation, replacement, sourceActor );
815     }
816     else
817     {
818       DALI_SCRIPT_WARNING( "Request for Animation called '%s' failed\n", animationName.c_str() );
819     }
820   }
821   else
822   {
823     DALI_SCRIPT_WARNING( "Request for Animation called '%s' failed (no animation section)\n", animationName.c_str() );
824   }
825
826   return anim;
827 }
828
829 Animation Builder::CreateAnimation( const std::string& animationName, const PropertyValueMap& map, Dali::Actor sourceActor )
830 {
831   Replacement replacement(map, mReplacementMap);
832   return CreateAnimation( animationName, replacement, sourceActor);
833 }
834
835 Animation Builder::CreateAnimation( const std::string& animationName, const PropertyValueMap& map )
836 {
837   Replacement replacement(map, mReplacementMap);
838   return CreateAnimation( animationName, replacement, Stage::GetCurrent().GetRootLayer() );
839 }
840
841 Animation Builder::CreateAnimation( const std::string& animationName, Dali::Actor sourceActor )
842 {
843   Replacement replacement( mReplacementMap );
844
845   return CreateAnimation( animationName, replacement, sourceActor );
846 }
847
848 Animation Builder::CreateAnimation( const std::string& animationName )
849 {
850   Replacement replacement( mReplacementMap );
851
852   return CreateAnimation( animationName, replacement, Dali::Stage::GetCurrent().GetRootLayer() );
853 }
854
855 void Builder::LoadFromString( std::string const& data, Dali::Toolkit::Builder::UIFormat format )
856 {
857   DALI_ASSERT_ALWAYS( format == Dali::Toolkit::Builder::JSON && "Currently only JSON is supported" );
858
859   // parser to get constants and includes only
860   Dali::Toolkit::JsonParser parser = Dali::Toolkit::JsonParser::New();
861
862   if( !parser.Parse( data ) )
863   {
864     DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
865                       parser.GetErrorLineNumber(),
866                       parser.GetErrorColumn(),
867                       parser.GetErrorDescription().c_str() );
868
869     DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
870
871   }
872   else
873   {
874     // load constant map (allows the user to override the constants in the json after loading)
875     LoadConstants( *parser.GetRoot(), mReplacementMap );
876
877     // merge includes
878     if( OptionalChild includes = IsChild(*parser.GetRoot(), KEYNAME_INCLUDES) )
879     {
880       Replacement replacer( mReplacementMap );
881
882       for(TreeNode::ConstIterator iter = (*includes).CBegin(); iter != (*includes).CEnd(); ++iter)
883       {
884         OptionalString filename = replacer.IsString( (*iter).second );
885
886         if( filename )
887         {
888 #if defined(DEBUG_ENABLED)
889           DALI_SCRIPT_VERBOSE("Loading Include '%s'\n", (*filename).c_str());
890 #endif
891           LoadFromString( GetFileContents(*filename) );
892         }
893       }
894     }
895
896     if( !mParser.Parse( data ) )
897     {
898       DALI_LOG_WARNING( "JSON Parse Error:%d:%d:'%s'\n",
899                         mParser.GetErrorLineNumber(),
900                         mParser.GetErrorColumn(),
901                         mParser.GetErrorDescription().c_str() );
902
903       DALI_ASSERT_ALWAYS(!"Cannot parse JSON");
904     }
905   }
906
907   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Cannot parse JSON");
908
909 }
910
911 void Builder::AddConstants( const PropertyValueMap& map )
912 {
913   for(PropertyValueMap::const_iterator iter = map.begin(); iter != map.end(); ++iter)
914   {
915     mReplacementMap[ (*iter).first ] = (*iter).second;
916   }
917 }
918
919 void Builder::AddConstant( const std::string& key, const Property::Value& value )
920 {
921   mReplacementMap[key] = value;
922 }
923
924 const PropertyValueMap& Builder::GetConstants() const
925 {
926   return mReplacementMap;
927 }
928
929 const Property::Value& Builder::GetConstant( const std::string& key ) const
930 {
931   PropertyValueMap::const_iterator iter = mReplacementMap.find( key );
932   if( iter  != mReplacementMap.end() )
933   {
934     return (*iter).second;
935   }
936   else
937   {
938     static Property::Value invalid;
939     return invalid;
940   }
941 }
942
943 void Builder::LoadConstants( const TreeNode& root, PropertyValueMap& intoMap )
944 {
945   Replacement replacer(intoMap);
946
947   if( OptionalChild constants = IsChild(root, "constants") )
948   {
949     for(TreeNode::ConstIterator iter = (*constants).CBegin();
950         iter != (*constants).CEnd(); ++iter)
951     {
952       Dali::Property::Value property;
953       if( (*iter).second.GetName() )
954       {
955 #if defined(DEBUG_ENABLED)
956         DALI_SCRIPT_VERBOSE("Constant set from json '%s'\n", (*iter).second.GetName());
957 #endif
958         if( SetPropertyFromNode( (*iter).second, property, replacer ) )
959         {
960           intoMap[ (*iter).second.GetName() ] = property;
961         }
962         else
963         {
964           DALI_SCRIPT_WARNING("Cannot convert property for constant %s\n",
965                               (*iter).second.GetName() == NULL ? "no name?" : (*iter).second.GetName());
966         }
967       }
968     }
969   }
970
971 #if defined(DEBUG_ENABLED)
972   PropertyValueMap::const_iterator iter = intoMap.find( "CONFIG_SCRIPT_LOG_LEVEL" );
973   if( iter != intoMap.end() && (*iter).second.GetType() == Property::STRING )
974   {
975     std::string logLevel( (*iter).second.Get< std::string >() );
976     if( logLevel == "NoLogging" )
977     {
978       gFilterScript->SetLogLevel( Integration::Log::NoLogging );
979     }
980     else if( logLevel == "Concise" )
981     {
982       gFilterScript->SetLogLevel( Integration::Log::Concise );
983     }
984     else if( logLevel == "General" )
985     {
986       gFilterScript->SetLogLevel( Integration::Log::General );
987     }
988     else if( logLevel == "Verbose" )
989     {
990       gFilterScript->SetLogLevel( Integration::Log::Verbose );
991     }
992   }
993 #endif
994
995 }
996
997 bool Builder::ApplyStyle( const std::string& styleName, Handle& handle )
998 {
999   Replacement replacer( mReplacementMap );
1000   return ApplyStyle( styleName, handle, replacer );
1001 }
1002
1003 bool Builder::ApplyStyle( const std::string& styleName, Handle& handle, const Replacement& replacement )
1004 {
1005   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1006
1007   OptionalChild styles = IsChild( *mParser.GetRoot(), KEYNAME_STYLES );
1008   OptionalChild style  = IsChild( *styles, styleName );
1009
1010   if( styles && style )
1011   {
1012     ApplyAllStyleProperties( *mParser.GetRoot(), *style, handle, replacement );
1013     return true;
1014   }
1015   else
1016   {
1017     DALI_SCRIPT_WARNING("No styles section to create style '%s'\n", styleName.c_str());
1018     return false;
1019   }
1020 }
1021
1022 BaseHandle Builder::Create( const std::string& templateName, const PropertyValueMap& map )
1023 {
1024   Replacement replacement( map, mReplacementMap );
1025   return Create( templateName, replacement );
1026 }
1027
1028 BaseHandle Builder::Create( const std::string& templateName, const Replacement& constant )
1029 {
1030   DALI_ASSERT_ALWAYS(mParser.GetRoot() && "Builder script not loaded");
1031
1032   BaseHandle baseHandle;
1033
1034   OptionalChild templates = IsChild(*mParser.GetRoot(), KEYNAME_TEMPLATES);
1035
1036   if( !templates )
1037   {
1038     DALI_SCRIPT_WARNING("No template section found to CreateFromTemplate\n");
1039   }
1040   else
1041   {
1042     OptionalChild childTemplate = IsChild(*templates, templateName);
1043     if(!childTemplate)
1044     {
1045       DALI_SCRIPT_WARNING("Template '%s' does not exist in template section\n", templateName.c_str());
1046     }
1047     else
1048     {
1049       OptionalString type = constant.IsString( IsChild(*childTemplate, KEYNAME_TYPE) );
1050
1051       if(!type)
1052       {
1053         DALI_SCRIPT_WARNING("Cannot create template '%s' as template section is missing 'type'\n", templateName.c_str());
1054       }
1055       else
1056       {
1057         baseHandle = DoCreate( *mParser.GetRoot(), *childTemplate, Actor(), constant );
1058       }
1059     }
1060   }
1061
1062   return baseHandle;
1063 }
1064
1065
1066 BaseHandle Builder::Create( const std::string& templateName )
1067 {
1068   Replacement replacement( mReplacementMap );
1069   return Create( templateName, replacement );
1070 }
1071
1072 Builder::Builder()
1073 : mSlotDelegate( this )
1074 {
1075   mParser = Dali::Toolkit::JsonParser::New();
1076 }
1077
1078 Builder::~Builder()
1079 {
1080 }
1081
1082 } // namespace Internal
1083
1084 } // namespace Toolkit
1085
1086 } // namespace Dali