Fix SCREEN_POSITION error

[platform/core/uifw/dali-core.git] / dali / internal / event / actors / actor-impl.cpp

diff --git a/dali/internal/event/actors/actor-impl.cpp b/dali/internal/event/actors/actor-impl.cpp
index 2bd9b83..d36e103 100644 (file)
--- a/dali/internal/event/actors/actor-impl.cpp
+++ b/dali/internal/event/actors/actor-impl.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.

  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.


@@ -24,15 +24,16 @@
 #include <cfloat>
 
 // INTERNAL INCLUDES
 #include <cfloat>
 
 // INTERNAL INCLUDES

-
+#include <dali/devel-api/actors/layer-devel.h>

 #include <dali/public-api/common/dali-common.h>
 #include <dali/public-api/common/constants.h>
 #include <dali/public-api/common/dali-common.h>
 #include <dali/public-api/common/constants.h>

+#include <dali/public-api/events/touch-data.h>

 #include <dali/public-api/math/vector2.h>
 #include <dali/public-api/math/vector3.h>
 #include <dali/public-api/math/radian.h>
 #include <dali/public-api/object/type-registry.h>
 #include <dali/public-api/math/vector2.h>
 #include <dali/public-api/math/vector3.h>
 #include <dali/public-api/math/radian.h>
 #include <dali/public-api/object/type-registry.h>

+#include <dali/devel-api/actors/actor-devel.h>

 #include <dali/devel-api/scripting/scripting.h>
 #include <dali/devel-api/scripting/scripting.h>

-

 #include <dali/internal/common/internal-constants.h>
 #include <dali/internal/event/common/event-thread-services.h>
 #include <dali/internal/event/render-tasks/render-task-impl.h>
 #include <dali/internal/common/internal-constants.h>
 #include <dali/internal/event/common/event-thread-services.h>
 #include <dali/internal/event/render-tasks/render-task-impl.h>


@@ -41,8 +42,6 @@
 #include <dali/internal/event/common/property-helper.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/common/type-info-impl.h>
 #include <dali/internal/event/common/property-helper.h>
 #include <dali/internal/event/common/stage-impl.h>
 #include <dali/internal/event/common/type-info-impl.h>

-#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
-#include <dali/internal/event/actor-attachments/renderer-attachment-impl.h>

 #include <dali/internal/event/animation/constraint-impl.h>
 #include <dali/internal/event/common/projection.h>
 #include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
 #include <dali/internal/event/animation/constraint-impl.h>
 #include <dali/internal/event/common/projection.h>
 #include <dali/internal/event/size-negotiation/relayout-controller-impl.h>


@@ -58,39 +57,13 @@ using Dali::Internal::SceneGraph::Node;
 using Dali::Internal::SceneGraph::AnimatableProperty;
 using Dali::Internal::SceneGraph::PropertyBase;
 
 using Dali::Internal::SceneGraph::AnimatableProperty;
 using Dali::Internal::SceneGraph::PropertyBase;
 

-namespace Dali
-{
-namespace ResizePolicy
-{
-
-namespace
-{
-DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )
-DALI_ENUM_TO_STRING( FIXED )
-DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
-DALI_ENUM_TO_STRING( FILL_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
-DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
-DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
-DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
-DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
-DALI_ENUM_TO_STRING_TABLE_END( Type )
-
-} // unnamed namespace
-} // ResizePolicy
+#if defined(DEBUG_ENABLED)
+Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_DEPTH_TIMER" );
+Debug::Filter* gLogRelayoutFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_RELAYOUT_TIMER" );
+#endif

 
 

-namespace SizeScalePolicy
-{
-namespace
+namespace Dali

 {
 {

-// Enumeration to / from string conversion tables
-DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )
-DALI_ENUM_TO_STRING( USE_SIZE_SET )
-DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_TABLE_END( Type )
-} // unnamed namespace
-} // SizeScalePolicy

 
 namespace Internal
 {
 
 namespace Internal
 {


@@ -133,6 +106,7 @@ struct Actor::RelayoutData
     for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
       resizePolicies[ i ] = ResizePolicy::DEFAULT;
     for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
       resizePolicies[ i ] = ResizePolicy::DEFAULT;

+      useAssignedSize[ i ] = false;

       negotiatedDimensions[ i ] = 0.0f;
       dimensionNegotiated[ i ] = false;
       dimensionDirty[ i ] = false;
       negotiatedDimensions[ i ] = 0.0f;
       dimensionNegotiated[ i ] = false;
       dimensionDirty[ i ] = false;


@@ -144,6 +118,7 @@ struct Actor::RelayoutData
   }
 
   ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ];      ///< Resize policies
   }
 
   ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ];      ///< Resize policies

+  bool useAssignedSize[ Dimension::DIMENSION_COUNT ];                   ///< The flag to specify whether the size should be assigned to the actor

 
   Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ];  ///< A list of dimension dependencies
 
 
   Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ];  ///< A list of dimension dependencies
 


@@ -175,70 +150,80 @@ namespace // unnamed namespace
 /**
  * We want to discourage the use of property strings (minimize string comparisons),
  * particularly for the default properties.
 /**
  * We want to discourage the use of property strings (minimize string comparisons),
  * particularly for the default properties.

- *              Name                Type   writable animatable constraint-input  enum for index-checking
+ *              Name                  Type   writable animatable constraint-input  enum for index-checking

  */
 DALI_PROPERTY_TABLE_BEGIN
  */
 DALI_PROPERTY_TABLE_BEGIN

-DALI_PROPERTY( "parent-origin",     VECTOR3,  true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN )
-DALI_PROPERTY( "parent-origin-x",   FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_X )
-DALI_PROPERTY( "parent-origin-y",   FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Y )
-DALI_PROPERTY( "parent-origin-z",   FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Z )
-DALI_PROPERTY( "anchor-point",      VECTOR3,  true,  false, true,  Dali::Actor::Property::ANCHOR_POINT )
-DALI_PROPERTY( "anchor-point-x",    FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_X )
-DALI_PROPERTY( "anchor-point-y",    FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Y )
-DALI_PROPERTY( "anchor-point-z",    FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Z )
-DALI_PROPERTY( "size",              VECTOR3,  true,  true,  true,  Dali::Actor::Property::SIZE )
-DALI_PROPERTY( "size-width",        FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_WIDTH )
-DALI_PROPERTY( "size-height",       FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_HEIGHT )
-DALI_PROPERTY( "size-depth",        FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_DEPTH )
-DALI_PROPERTY( "position",          VECTOR3,  true,  true,  true,  Dali::Actor::Property::POSITION )
-DALI_PROPERTY( "position-x",        FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_X )
-DALI_PROPERTY( "position-y",        FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Y )
-DALI_PROPERTY( "position-z",        FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Z )
-DALI_PROPERTY( "world-position",    VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_POSITION )
-DALI_PROPERTY( "world-position-x",  FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_X )
-DALI_PROPERTY( "world-position-y",  FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Y )
-DALI_PROPERTY( "world-position-z",  FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Z )
-DALI_PROPERTY( "orientation",       ROTATION, true,  true,  true,  Dali::Actor::Property::ORIENTATION )
-DALI_PROPERTY( "world-orientation", ROTATION, false, false, true,  Dali::Actor::Property::WORLD_ORIENTATION )
-DALI_PROPERTY( "scale",             VECTOR3,  true,  true,  true,  Dali::Actor::Property::SCALE )
-DALI_PROPERTY( "scale-x",           FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_X )
-DALI_PROPERTY( "scale-y",           FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Y )
-DALI_PROPERTY( "scale-z",           FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Z )
-DALI_PROPERTY( "world-scale",       VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_SCALE )
-DALI_PROPERTY( "visible",           BOOLEAN,  true,  true,  true,  Dali::Actor::Property::VISIBLE )
-DALI_PROPERTY( "color",             VECTOR4,  true,  true,  true,  Dali::Actor::Property::COLOR )
-DALI_PROPERTY( "color-red",         FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_RED )
-DALI_PROPERTY( "color-green",       FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_GREEN )
-DALI_PROPERTY( "color-blue",        FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_BLUE )
-DALI_PROPERTY( "color-alpha",       FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_ALPHA )
-DALI_PROPERTY( "world-color",       VECTOR4,  false, false, true,  Dali::Actor::Property::WORLD_COLOR )
-DALI_PROPERTY( "world-matrix",      MATRIX,   false, false, true,  Dali::Actor::Property::WORLD_MATRIX )
-DALI_PROPERTY( "name",              STRING,   true,  false, false, Dali::Actor::Property::NAME )
-DALI_PROPERTY( "sensitive",         BOOLEAN,  true,  false, false, Dali::Actor::Property::SENSITIVE )
-DALI_PROPERTY( "leave-required",    BOOLEAN,  true,  false, false, Dali::Actor::Property::LEAVE_REQUIRED )
-DALI_PROPERTY( "inherit-orientation",BOOLEAN, true,  false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
-DALI_PROPERTY( "inherit-scale",     BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_SCALE )
-DALI_PROPERTY( "color-mode",        STRING,   true,  false, false, Dali::Actor::Property::COLOR_MODE )
-DALI_PROPERTY( "position-inheritance",STRING, true,  false, false, Dali::Actor::Property::POSITION_INHERITANCE )
-DALI_PROPERTY( "draw-mode",         STRING,   true,  false, false, Dali::Actor::Property::DRAW_MODE )
-DALI_PROPERTY( "size-mode-factor",  VECTOR3,  true,  false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
-DALI_PROPERTY( "width-resize-policy",STRING,  true,  false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
-DALI_PROPERTY( "height-resize-policy",STRING, true,  false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
-DALI_PROPERTY( "size-scale-policy", STRING,   true,  false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
-DALI_PROPERTY( "width-for-height",  BOOLEAN,  true,  false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
-DALI_PROPERTY( "height-for-width",  BOOLEAN,  true,  false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
-DALI_PROPERTY( "padding",           VECTOR4,  true,  false, false, Dali::Actor::Property::PADDING )
-DALI_PROPERTY( "minimum-size",      VECTOR2,  true,  false, false, Dali::Actor::Property::MINIMUM_SIZE )
-DALI_PROPERTY( "maximum-size",      VECTOR2,  true,  false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY( "parentOrigin",              VECTOR3,  true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN )
+DALI_PROPERTY( "parentOriginX",             FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_X )
+DALI_PROPERTY( "parentOriginY",             FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Y )
+DALI_PROPERTY( "parentOriginZ",             FLOAT,    true,  false, true,  Dali::Actor::Property::PARENT_ORIGIN_Z )
+DALI_PROPERTY( "anchorPoint",               VECTOR3,  true,  false, true,  Dali::Actor::Property::ANCHOR_POINT )
+DALI_PROPERTY( "anchorPointX",              FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_X )
+DALI_PROPERTY( "anchorPointY",              FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Y )
+DALI_PROPERTY( "anchorPointZ",              FLOAT,    true,  false, true,  Dali::Actor::Property::ANCHOR_POINT_Z )
+DALI_PROPERTY( "size",                      VECTOR3,  true,  true,  true,  Dali::Actor::Property::SIZE )
+DALI_PROPERTY( "sizeWidth",                 FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_WIDTH )
+DALI_PROPERTY( "sizeHeight",                FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_HEIGHT )
+DALI_PROPERTY( "sizeDepth",                 FLOAT,    true,  true,  true,  Dali::Actor::Property::SIZE_DEPTH )
+DALI_PROPERTY( "position",                  VECTOR3,  true,  true,  true,  Dali::Actor::Property::POSITION )
+DALI_PROPERTY( "positionX",                 FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_X )
+DALI_PROPERTY( "positionY",                 FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Y )
+DALI_PROPERTY( "positionZ",                 FLOAT,    true,  true,  true,  Dali::Actor::Property::POSITION_Z )
+DALI_PROPERTY( "worldPosition",             VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_POSITION )
+DALI_PROPERTY( "worldPositionX",            FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_X )
+DALI_PROPERTY( "worldPositionY",            FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Y )
+DALI_PROPERTY( "worldPositionZ",            FLOAT,    false, false, true,  Dali::Actor::Property::WORLD_POSITION_Z )
+DALI_PROPERTY( "orientation",               ROTATION, true,  true,  true,  Dali::Actor::Property::ORIENTATION )
+DALI_PROPERTY( "worldOrientation",          ROTATION, false, false, true,  Dali::Actor::Property::WORLD_ORIENTATION )
+DALI_PROPERTY( "scale",                     VECTOR3,  true,  true,  true,  Dali::Actor::Property::SCALE )
+DALI_PROPERTY( "scaleX",                    FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_X )
+DALI_PROPERTY( "scaleY",                    FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Y )
+DALI_PROPERTY( "scaleZ",                    FLOAT,    true,  true,  true,  Dali::Actor::Property::SCALE_Z )
+DALI_PROPERTY( "worldScale",                VECTOR3,  false, false, true,  Dali::Actor::Property::WORLD_SCALE )
+DALI_PROPERTY( "visible",                   BOOLEAN,  true,  true,  true,  Dali::Actor::Property::VISIBLE )
+DALI_PROPERTY( "color",                     VECTOR4,  true,  true,  true,  Dali::Actor::Property::COLOR )
+DALI_PROPERTY( "colorRed",                  FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_RED )
+DALI_PROPERTY( "colorGreen",                FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_GREEN )
+DALI_PROPERTY( "colorBlue",                 FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_BLUE )
+DALI_PROPERTY( "colorAlpha",                FLOAT,    true,  true,  true,  Dali::Actor::Property::COLOR_ALPHA )
+DALI_PROPERTY( "worldColor",                VECTOR4,  false, false, true,  Dali::Actor::Property::WORLD_COLOR )
+DALI_PROPERTY( "worldMatrix",               MATRIX,   false, false, true,  Dali::Actor::Property::WORLD_MATRIX )
+DALI_PROPERTY( "name",                      STRING,   true,  false, false, Dali::Actor::Property::NAME )
+DALI_PROPERTY( "sensitive",                 BOOLEAN,  true,  false, false, Dali::Actor::Property::SENSITIVE )
+DALI_PROPERTY( "leaveRequired",             BOOLEAN,  true,  false, false, Dali::Actor::Property::LEAVE_REQUIRED )
+DALI_PROPERTY( "inheritOrientation",        BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_ORIENTATION )
+DALI_PROPERTY( "inheritScale",              BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_SCALE )
+DALI_PROPERTY( "colorMode",                 STRING,   true,  false, false, Dali::Actor::Property::COLOR_MODE )
+DALI_PROPERTY( "positionInheritance",       STRING,   true,  false, false, Dali::Actor::Property::POSITION_INHERITANCE )
+DALI_PROPERTY( "drawMode",                  STRING,   true,  false, false, Dali::Actor::Property::DRAW_MODE )
+DALI_PROPERTY( "sizeModeFactor",            VECTOR3,  true,  false, false, Dali::Actor::Property::SIZE_MODE_FACTOR )
+DALI_PROPERTY( "widthResizePolicy",         STRING,   true,  false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY )
+DALI_PROPERTY( "heightResizePolicy",        STRING,   true,  false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY )
+DALI_PROPERTY( "sizeScalePolicy",           STRING,   true,  false, false, Dali::Actor::Property::SIZE_SCALE_POLICY )
+DALI_PROPERTY( "widthForHeight",            BOOLEAN,  true,  false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT )
+DALI_PROPERTY( "heightForWidth",            BOOLEAN,  true,  false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH )
+DALI_PROPERTY( "padding",                   VECTOR4,  true,  false, false, Dali::Actor::Property::PADDING )
+DALI_PROPERTY( "minimumSize",               VECTOR2,  true,  false, false, Dali::Actor::Property::MINIMUM_SIZE )
+DALI_PROPERTY( "maximumSize",               VECTOR2,  true,  false, false, Dali::Actor::Property::MAXIMUM_SIZE )
+DALI_PROPERTY( "inheritPosition",           BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_POSITION )
+DALI_PROPERTY( "clippingMode",              STRING,   true,  false, false, Dali::Actor::Property::CLIPPING_MODE )
+DALI_PROPERTY( "layoutDirection",           STRING,   true,  false, false, Dali::Actor::Property::LAYOUT_DIRECTION )
+DALI_PROPERTY( "inheritLayoutDirection",    BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION )
+DALI_PROPERTY( "siblingOrder",              INTEGER,  true,  false, false, Dali::DevelActor::Property::SIBLING_ORDER )
+DALI_PROPERTY( "opacity",                   FLOAT,    true,  true,  true,  Dali::DevelActor::Property::OPACITY )
+DALI_PROPERTY( "screenPosition",            VECTOR2,  false, false, false, Dali::DevelActor::Property::SCREEN_POSITION )
+DALI_PROPERTY( "positionUsesAnchorPoint",   BOOLEAN,  true,  false, false, Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT )

 DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
 
 // Signals
 
 const char* const SIGNAL_TOUCHED = "touched";
 const char* const SIGNAL_HOVERED = "hovered";
 DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
 
 // Signals
 
 const char* const SIGNAL_TOUCHED = "touched";
 const char* const SIGNAL_HOVERED = "hovered";

-const char* const SIGNAL_WHEEL_EVENT = "wheel-event";
-const char* const SIGNAL_ON_STAGE = "on-stage";
-const char* const SIGNAL_OFF_STAGE = "off-stage";
+const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
+const char* const SIGNAL_ON_STAGE = "onStage";
+const char* const SIGNAL_OFF_STAGE = "offStage";
+const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
+const char* const SIGNAL_TOUCH = "touch";

 
 // Actions
 
 
 // Actions
 


@@ -254,12 +239,100 @@ TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor )
 
 SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
 
 SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );

-SignalConnectorType signalConnector3( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
-SignalConnectorType signalConnector4( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector3( mType, SIGNAL_WHEEL_EVENT, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector4( mType, SIGNAL_ON_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_OFF_STAGE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal );

 
 TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
 TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
 
 
 TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
 TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
 

+struct AnchorValue
+{
+  const char* name;
+  const Vector3& value;
+};
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( AnchorValue, ANCHOR_CONSTANT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_LEFT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_CENTER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_LEFT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_LEFT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_CENTER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_RIGHT )
+DALI_ENUM_TO_STRING_TABLE_END( ANCHOR_CONSTANT )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( COLOR_MODE )
+DALI_ENUM_TO_STRING( USE_OWN_COLOR )
+DALI_ENUM_TO_STRING( USE_PARENT_COLOR )
+DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_COLOR )
+DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_ALPHA )
+DALI_ENUM_TO_STRING_TABLE_END( COLOR_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( POSITION_INHERITANCE_MODE )
+DALI_ENUM_TO_STRING( INHERIT_PARENT_POSITION )
+DALI_ENUM_TO_STRING( USE_PARENT_POSITION )
+DALI_ENUM_TO_STRING( USE_PARENT_POSITION_PLUS_LOCAL_POSITION )
+DALI_ENUM_TO_STRING( DONT_INHERIT_POSITION )
+DALI_ENUM_TO_STRING_TABLE_END( POSITION_INHERITANCE_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( DRAW_MODE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, NORMAL )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, OVERLAY_2D )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, STENCIL )
+DALI_ENUM_TO_STRING_TABLE_END( DRAW_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( RESIZE_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIXED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_NATURAL_SIZE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FILL_TO_PARENT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_RELATIVE_TO_PARENT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_FIXED_OFFSET_FROM_PARENT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIT_TO_CHILDREN )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, DIMENSION_DEPENDENCY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_ASSIGNED_SIZE )
+DALI_ENUM_TO_STRING_TABLE_END( RESIZE_POLICY )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( SIZE_SCALE_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, USE_SIZE_SET )
+DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FIT_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FILL_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING_TABLE_END( SIZE_SCALE_POLICY )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN )
+DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( LAYOUT_DIRECTION )
+DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, LEFT_TO_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, RIGHT_TO_LEFT )
+DALI_ENUM_TO_STRING_TABLE_END( LAYOUT_DIRECTION )
+
+bool GetAnchorPointConstant( const std::string& value, Vector3& anchor )
+{
+  for( unsigned int i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
+  {
+    size_t sizeIgnored = 0;
+    if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
+    {
+      anchor = ANCHOR_CONSTANT_TABLE[ i ].value;
+      return true;
+    }
+  }
+  return false;
+}
+
+inline bool GetParentOriginConstant( const std::string& value, Vector3& parentOrigin )
+{
+  // Values are the same so just use the same table as anchor-point
+  return GetAnchorPointConstant( value, parentOrigin );
+}
+

 /**
  * @brief Extract a given dimension from a Vector2
  *
 /**
  * @brief Extract a given dimension from a Vector2
  *


@@ -299,6 +372,28 @@ float GetDimensionValue( const Vector3& values, Dimension::Type dimension )
   return GetDimensionValue( values.GetVectorXY(), dimension );
 }
 
   return GetDimensionValue( values.GetVectorXY(), dimension );
 }
 

+/**
+ * @brief Recursively emits the visibility-changed-signal on the actor tree.
+ * @param[in] actor The actor to emit the signal on
+ * @param[in] visible The new visibility of the actor
+ * @param[in] type Whether the actor's visible property has changed or a parent's
+ */
+void EmitVisibilityChangedSignalRecursively( ActorPtr actor, bool visible, DevelActor::VisibilityChange::Type type )
+{
+  if( actor )
+  {
+    actor->EmitVisibilityChangedSignal( visible, type );
+
+    if( actor->GetChildCount() > 0 )
+    {
+      ActorContainer& children = actor->GetChildrenInternal();
+      for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+      {
+        EmitVisibilityChangedSignalRecursively( *iter, visible, DevelActor::VisibilityChange::PARENT );
+      }
+    }
+  }
+}

 
 } // unnamed namespace
 
 
 } // unnamed namespace
 


@@ -333,23 +428,6 @@ unsigned int Actor::GetId() const
   return mId;
 }
 
   return mId;
 }
 

-void Actor::Attach( ActorAttachment& attachment )
-{
-  DALI_ASSERT_DEBUG( !mAttachment && "An Actor can only have one attachment" );
-
-  if( OnStage() )
-  {
-    attachment.Connect();
-  }
-
-  mAttachment = ActorAttachmentPtr( &attachment );
-}
-
-ActorAttachmentPtr Actor::GetAttachment()
-{
-  return mAttachment;
-}
-

 bool Actor::OnStage() const
 {
   return mIsOnStage;
 bool Actor::OnStage() const
 {
   return mIsOnStage;


@@ -416,6 +494,8 @@ void Actor::Add( Actor& child )
       // Notification for derived classes
       OnChildAdd( child );
 
       // Notification for derived classes
       OnChildAdd( child );
 

+      InheritLayoutDirectionRecursively( ActorPtr( &child ), mLayoutDirection );
+

       // Only put in a relayout request if there is a suitable dependency
       if( RelayoutDependentOnChildren() )
       {
       // Only put in a relayout request if there is a suitable dependency
       if( RelayoutDependentOnChildren() )
       {


@@ -458,15 +538,15 @@ void Actor::Remove( Actor& child )
 
   if( removed )
   {
 
   if( removed )
   {

-    // Notification for derived classes
-    OnChildRemove( *(removed.Get()) );
-

     // Only put in a relayout request if there is a suitable dependency
     if( RelayoutDependentOnChildren() )
     {
       RelayoutRequest();
     }
   }
     // Only put in a relayout request if there is a suitable dependency
     if( RelayoutDependentOnChildren() )
     {
       RelayoutRequest();
     }
   }

+
+  // Notification for derived classes
+  OnChildRemove( child );

 }
 
 void Actor::Unparent()
 }
 
 void Actor::Unparent()


@@ -657,7 +737,7 @@ void Actor::SetPosition( const Vector3& position )
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::Bake, position );
+    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );

   }
 }
 
   }
 }
 


@@ -668,7 +748,7 @@ void Actor::SetX( float x )
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeX, x );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );

   }
 }
 
   }
 }
 


@@ -679,7 +759,7 @@ void Actor::SetY( float y )
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeY, y );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );

   }
 }
 
   }
 }
 


@@ -690,7 +770,7 @@ void Actor::SetZ( float z )
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeZ, z );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );

   }
 }
 
   }
 }
 


@@ -701,7 +781,7 @@ void Actor::TranslateBy( const Vector3& distance )
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &AnimatableProperty<Vector3>::BakeRelative, distance );
+    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );

   }
 }
 
   }
 }
 


@@ -732,6 +812,24 @@ const Vector3& Actor::GetCurrentWorldPosition() const
   return Vector3::ZERO;
 }
 
   return Vector3::ZERO;
 }
 

+const Vector2 Actor::GetCurrentScreenPosition() const
+{
+  if( OnStage() && NULL != mNode )
+  {
+    StagePtr stage = Stage::GetCurrent();
+    Vector3 worldPosition =  mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+    Vector3 actorSize = GetCurrentSize() * GetCurrentWorldScale();
+    Vector2 halfStageSize( stage->GetSize() * 0.5f ); // World position origin is center of stage
+    Vector3 halfActorSize( actorSize * 0.5f );
+    Vector3 anchorPointOffSet = halfActorSize - actorSize * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
+
+    return Vector2( halfStageSize.width + worldPosition.x - anchorPointOffSet.x,
+                    halfStageSize.height + worldPosition.y - anchorPointOffSet.y );
+  }
+
+  return Vector2::ZERO;
+}
+

 void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode )
 {
   // this flag is not animatable so keep the value
 void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode )
 {
   // this flag is not animatable so keep the value


@@ -739,7 +837,7 @@ void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode )
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value

-    SetPositionInheritanceModeMessage( GetEventThreadServices(), *mNode, mode );
+    SetInheritPositionMessage( GetEventThreadServices(), *mNode, mode == INHERIT_PARENT_POSITION );

   }
 }
 
   }
 }
 


@@ -749,6 +847,21 @@ PositionInheritanceMode Actor::GetPositionInheritanceMode() const
   return mPositionInheritanceMode;
 }
 
   return mPositionInheritanceMode;
 }
 

+void Actor::SetInheritPosition( bool inherit )
+{
+  if( mInheritPosition != inherit && NULL != mNode )
+  {
+    // non animateable so keep local copy
+    mInheritPosition = inherit;
+    SetInheritPositionMessage( GetEventThreadServices(), *mNode, inherit );
+  }
+}
+
+bool Actor::IsPositionInherited() const
+{
+  return mInheritPosition;
+}
+

 void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
 {
   Vector3 normalizedAxis( axis.x, axis.y, axis.z );
 void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
 {
   Vector3 normalizedAxis( axis.x, axis.y, axis.z );


@@ -761,28 +874,28 @@ void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
 
 void Actor::SetOrientation( const Quaternion& orientation )
 {
 
 void Actor::SetOrientation( const Quaternion& orientation )
 {

+  mTargetOrientation = orientation;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::Bake, orientation );
+    SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );

   }
 }
 
 void Actor::RotateBy( const Radian& angle, const Vector3& axis )
 {
   }
 }
 
 void Actor::RotateBy( const Radian& angle, const Vector3& axis )
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, Quaternion(angle, axis) );
-  }
+  RotateBy( Quaternion(angle, axis) );

 }
 
 void Actor::RotateBy( const Quaternion& relativeRotation )
 {
 }
 
 void Actor::RotateBy( const Quaternion& relativeRotation )
 {

+  mTargetOrientation *= Quaternion( relativeRotation );
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &AnimatableProperty<Quaternion>::BakeRelative, relativeRotation );
+    SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );

   }
 }
 
   }
 }
 


@@ -820,46 +933,56 @@ void Actor::SetScale( float x, float y, float z )
 
 void Actor::SetScale( const Vector3& scale )
 {
 
 void Actor::SetScale( const Vector3& scale )
 {

+  mTargetScale = scale;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::Bake, scale );
+    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );

   }
 }
 
 void Actor::SetScaleX( float x )
 {
   }
 }
 
 void Actor::SetScaleX( float x )
 {

+  mTargetScale.x = x;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeX, x );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );

   }
 }
 
 void Actor::SetScaleY( float y )
 {
   }
 }
 
 void Actor::SetScaleY( float y )
 {

+  mTargetScale.y = y;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeY, y );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );

   }
 }
 
 void Actor::SetScaleZ( float z )
 {
   }
 }
 
 void Actor::SetScaleZ( float z )
 {

+  mTargetScale.z = z;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeZ, z );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );

   }
 }
 
 void Actor::ScaleBy(const Vector3& relativeScale)
 {
   }
 }
 
 void Actor::ScaleBy(const Vector3& relativeScale)
 {

+  mTargetScale *= relativeScale;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &AnimatableProperty<Vector3>::BakeRelativeMultiply, relativeScale );
+    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );

   }
 }
 
   }
 }
 


@@ -887,10 +1010,11 @@ const Vector3& Actor::GetCurrentWorldScale() const
 
 void Actor::SetInheritScale( bool inherit )
 {
 
 void Actor::SetInheritScale( bool inherit )
 {

-  // non animateable so keep local copy
-  mInheritScale = inherit;
-  if( NULL != mNode )
+
+  if( mInheritScale != inherit && NULL != mNode )

   {
   {

+    // non animateable so keep local copy
+    mInheritScale = inherit;

     // mNode is being used in a separate thread; queue a message to set the value
     SetInheritScaleMessage( GetEventThreadServices(), *mNode, inherit );
   }
     // mNode is being used in a separate thread; queue a message to set the value
     SetInheritScaleMessage( GetEventThreadServices(), *mNode, inherit );
   }


@@ -905,14 +1029,7 @@ Matrix Actor::GetCurrentWorldMatrix() const
 {
   if( NULL != mNode )
   {
 {
   if( NULL != mNode )
   {

-    // World matrix is no longer updated unless there is something observing the node.
-    // Need to calculate it from node's world position, orientation and scale:
-    BufferIndex updateBufferIndex = GetEventThreadServices().GetEventBufferIndex();
-    Matrix worldMatrix(false);
-    worldMatrix.SetTransformComponents( mNode->GetWorldScale( updateBufferIndex ),
-                                        mNode->GetWorldOrientation( updateBufferIndex ),
-                                        mNode->GetWorldPosition( updateBufferIndex ) );
-    return worldMatrix;
+    return mNode->GetWorldMatrix(0);

   }
 
   return Matrix::IDENTITY;
   }
 
   return Matrix::IDENTITY;


@@ -920,11 +1037,7 @@ Matrix Actor::GetCurrentWorldMatrix() const
 
 void Actor::SetVisible( bool visible )
 {
 
 void Actor::SetVisible( bool visible )
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
-  }
+  SetVisibleInternal( visible, SendMessage::TRUE );

 }
 
 bool Actor::IsVisible() const
 }
 
 bool Actor::IsVisible() const


@@ -940,6 +1053,8 @@ bool Actor::IsVisible() const
 
 void Actor::SetOpacity( float opacity )
 {
 
 void Actor::SetOpacity( float opacity )
 {

+  mTargetColor.a = opacity;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value


@@ -958,6 +1073,16 @@ float Actor::GetCurrentOpacity() const
   return 1.0f;
 }
 
   return 1.0f;
 }
 

+ClippingMode::Type Actor::GetClippingMode() const
+{
+  return mClippingMode;
+}
+
+unsigned int Actor::GetSortingDepth()
+{
+  return mSortedDepth;
+}
+

 const Vector4& Actor::GetCurrentWorldColor() const
 {
   if( NULL != mNode )
 const Vector4& Actor::GetCurrentWorldColor() const
 {
   if( NULL != mNode )


@@ -970,6 +1095,8 @@ const Vector4& Actor::GetCurrentWorldColor() const
 
 void Actor::SetColor( const Vector4& color )
 {
 
 void Actor::SetColor( const Vector4& color )
 {

+  mTargetColor = color;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value


@@ -979,6 +1106,8 @@ void Actor::SetColor( const Vector4& color )
 
 void Actor::SetColorRed( float red )
 {
 
 void Actor::SetColorRed( float red )
 {

+  mTargetColor.r = red;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value


@@ -988,6 +1117,8 @@ void Actor::SetColorRed( float red )
 
 void Actor::SetColorGreen( float green )
 {
 
 void Actor::SetColorGreen( float green )
 {

+  mTargetColor.g = green;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value


@@ -997,6 +1128,8 @@ void Actor::SetColorGreen( float green )
 
 void Actor::SetColorBlue( float blue )
 {
 
 void Actor::SetColorBlue( float blue )
 {

+  mTargetColor.b = blue;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value


@@ -1017,10 +1150,10 @@ const Vector4& Actor::GetCurrentColor() const
 
 void Actor::SetInheritOrientation( bool inherit )
 {
 
 void Actor::SetInheritOrientation( bool inherit )
 {

-  // non animateable so keep local copy
-  mInheritOrientation = inherit;
-  if( NULL != mNode )
+  if( mInheritOrientation != inherit && NULL != mNode)

   {
   {

+    // non animateable so keep local copy
+    mInheritOrientation = inherit;

     // mNode is being used in a separate thread; queue a message to set the value
     SetInheritOrientationMessage( GetEventThreadServices(), *mNode, inherit );
   }
     // mNode is being used in a separate thread; queue a message to set the value
     SetInheritOrientationMessage( GetEventThreadServices(), *mNode, inherit );
   }


@@ -1077,23 +1210,19 @@ void Actor::SetSize( float width, float height, float depth )
 
 void Actor::SetSize( const Vector2& size )
 {
 
 void Actor::SetSize( const Vector2& size )
 {

-  SetSize( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
+  SetSize( Vector3( size.width, size.height, 0.f ) );

 }
 
 void Actor::SetSizeInternal( const Vector2& size )
 {
 }
 
 void Actor::SetSizeInternal( const Vector2& size )
 {

-  SetSizeInternal( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
-}
-
-float Actor::CalculateSizeZ( const Vector2& size ) const
-{
-  return std::min( size.width, size.height );
+  SetSizeInternal( Vector3( size.width, size.height, 0.f ) );

 }
 
 void Actor::SetSize( const Vector3& size )
 {
   if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
   {
 }
 
 void Actor::SetSize( const Vector3& size )
 {
   if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
   {

+    // TODO we cannot just ignore the given Z but that means rewrite the size negotiation!!

     SetPreferredSize( size.GetVectorXY() );
   }
   else
     SetPreferredSize( size.GetVectorXY() );
   }
   else


@@ -1115,7 +1244,7 @@ void Actor::SetSizeInternal( const Vector3& size )
     mTargetSize = size;
 
     // mNode is being used in a separate thread; queue a message to set the value & base value
     mTargetSize = size;
 
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::Bake, mTargetSize );
+    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );

 
     // Notification for derived classes
     mInsideOnSizeSet = true;
 
     // Notification for derived classes
     mInsideOnSizeSet = true;


@@ -1130,58 +1259,74 @@ void Actor::SetSizeInternal( const Vector3& size )
   }
 }
 
   }
 }
 

-void Actor::NotifySizeAnimation( Animation& animation, const Vector3& targetSize )
+void Actor::SetWidth( float width )

 {
 {

-  mTargetSize = targetSize;
+  if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
+  {
+    SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
+    mRelayoutData->preferredSize.width = width;
+  }
+  else
+  {
+    mTargetSize.width = width;
+
+    if( NULL != mNode )
+    {
+      // mNode is being used in a separate thread; queue a message to set the value & base value
+      SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );
+    }
+  }

 
 

-  // Notify deriving classes
-  OnSizeAnimation( animation, mTargetSize );
+  RelayoutRequest();

 }
 
 }
 

-void Actor::NotifySizeAnimation( Animation& animation, float targetSize, Property::Index property )
+void Actor::SetHeight( float height )

 {
 {

-  if ( Dali::Actor::Property::SIZE_WIDTH == property )
+  if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )

   {
   {

-    mTargetSize.width = targetSize;
+    SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
+    mRelayoutData->preferredSize.height = height;

   }
   }

-  else if ( Dali::Actor::Property::SIZE_HEIGHT == property )
+  else

   {
   {

-    mTargetSize.height = targetSize;
+    mTargetSize.height = height;
+
+    if( NULL != mNode )
+    {
+      // mNode is being used in a separate thread; queue a message to set the value & base value
+      SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );
+    }

   }
   }

-  // Notify deriving classes
-  OnSizeAnimation( animation, mTargetSize );
+
+  RelayoutRequest();

 }
 
 }
 

-void Actor::SetWidth( float width )
+void Actor::SetDepth( float depth )

 {
 {

+  mTargetSize.depth = depth;
+

   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value
   if( NULL != mNode )
   {
     // mNode is being used in a separate thread; queue a message to set the value & base value

-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeX, width );
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );

   }
 }
 
   }
 }
 

-void Actor::SetHeight( float height )
+Vector3 Actor::GetTargetSize() const

 {
 {

-  if( NULL != mNode )
+  Vector3 size = mTargetSize;
+
+  // Should return preferred size if size is fixed as set by SetSize
+  if( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::FIXED )

   {
   {

-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeY, height );
+    size.width = GetPreferredSize().width;

   }
   }

-}
-
-void Actor::SetDepth( float depth )
-{
-  if( NULL != mNode )
+  if( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::FIXED )

   {
   {

-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &AnimatableProperty<Vector3>::BakeZ, depth );
+    size.height = GetPreferredSize().height;

   }
   }

-}

 
 

-const Vector3& Actor::GetTargetSize() const
-{
-  return mTargetSize;
+  return size;

 }
 
 const Vector3& Actor::GetCurrentSize() const
 }
 
 const Vector3& Actor::GetCurrentSize() const


@@ -1205,11 +1350,22 @@ void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimensio
 {
   EnsureRelayoutData();
 
 {
   EnsureRelayoutData();
 

+  ResizePolicy::Type originalWidthPolicy = GetResizePolicy(Dimension::WIDTH);
+  ResizePolicy::Type originalHeightPolicy = GetResizePolicy(Dimension::HEIGHT);
+

   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
   {
     if( dimension & ( 1 << i ) )
     {
   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
   {
     if( dimension & ( 1 << i ) )
     {

-      mRelayoutData->resizePolicies[ i ] = policy;
+      if ( policy == ResizePolicy::USE_ASSIGNED_SIZE )
+      {
+        mRelayoutData->useAssignedSize[ i ] = true;
+      }
+      else
+      {
+        mRelayoutData->resizePolicies[ i ] = policy;
+        mRelayoutData->useAssignedSize[ i ] = false;
+      }

     }
   }
 
     }
   }
 


@@ -1229,6 +1385,34 @@ void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimensio
   // If calling SetResizePolicy, assume we want relayout enabled
   SetRelayoutEnabled( true );
 
   // If calling SetResizePolicy, assume we want relayout enabled
   SetRelayoutEnabled( true );
 

+  // If the resize policy is set to be FIXED, the preferred size
+  // should be overrided by the target size. Otherwise the target
+  // size should be overrided by the preferred size.
+
+  if( dimension & Dimension::WIDTH )
+  {
+    if( originalWidthPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
+    {
+      mRelayoutData->preferredSize.width = mTargetSize.width;
+    }
+    else if( originalWidthPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
+    {
+      mTargetSize.width = mRelayoutData->preferredSize.width;
+    }
+  }
+
+  if( dimension & Dimension::HEIGHT )
+  {
+    if( originalHeightPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
+    {
+      mRelayoutData->preferredSize.height = mTargetSize.height;
+    }
+    else if( originalHeightPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
+    {
+      mTargetSize.height = mRelayoutData->preferredSize.height;
+    }
+  }
+

   OnSetResizePolicy( policy, dimension );
 
   // Trigger relayout on this control
   OnSetResizePolicy( policy, dimension );
 
   // Trigger relayout on this control


@@ -1244,7 +1428,14 @@ ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
     {
       if( ( dimension & ( 1 << i ) ) )
       {
     {
       if( ( dimension & ( 1 << i ) ) )
       {

-        return mRelayoutData->resizePolicies[ i ];
+        if( mRelayoutData->useAssignedSize[ i ] )
+        {
+          return ResizePolicy::USE_ASSIGNED_SIZE;
+        }
+        else
+        {
+          return mRelayoutData->resizePolicies[ i ];
+        }

       }
     }
   }
       }
     }
   }


@@ -1307,6 +1498,8 @@ void Actor::SetRelayoutEnabled( bool relayoutEnabled )
   {
     EnsureRelayoutData();
 
   {
     EnsureRelayoutData();
 

+    DALI_ASSERT_DEBUG( mRelayoutData && "mRelayoutData not created" );
+

     mRelayoutData->relayoutEnabled = relayoutEnabled;
   }
 }
     mRelayoutData->relayoutEnabled = relayoutEnabled;
   }
 }


@@ -1359,56 +1552,64 @@ bool Actor::RelayoutRequired( Dimension::Type dimension ) const
 
 unsigned int Actor::AddRenderer( Renderer& renderer )
 {
 
 unsigned int Actor::AddRenderer( Renderer& renderer )
 {

-  //TODO: MESH_REWORK : Add support for multiple renderers
-  if ( ! mAttachment )
+  if( !mRenderers )

   {
   {

-    mAttachment = RendererAttachment::New( GetEventThreadServices(), *mNode, renderer );
-    if( mIsOnStage )
-    {
-      mAttachment->Connect();
-    }
+    mRenderers = new RendererContainer;

   }
 
   }
 

-  return 0;
+  unsigned int index = mRenderers->size();
+  RendererPtr rendererPtr = RendererPtr( &renderer );
+  mRenderers->push_back( rendererPtr );
+  AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+  return index;

 }
 
 unsigned int Actor::GetRendererCount() const
 {
 }
 
 unsigned int Actor::GetRendererCount() const
 {

-  //TODO: MESH_REWORK : Add support for multiple renderers
-  RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
-  return attachment ? 1u : 0u;
+  unsigned int rendererCount(0);
+  if( mRenderers )
+  {
+    rendererCount = mRenderers->size();
+  }
+
+  return rendererCount;

 }
 
 }
 

-Renderer& Actor::GetRendererAt( unsigned int index )
+RendererPtr Actor::GetRendererAt( unsigned int index )

 {
 {

-  //TODO: MESH_REWORK : Add support for multiple renderers
-  DALI_ASSERT_DEBUG( index == 0 && "Only one renderer is supported." );
-
-  //TODO: MESH_REWORK : Temporary code
-  RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
-  DALI_ASSERT_ALWAYS( attachment && "Actor doesn't have a renderer" );
+  RendererPtr renderer;
+  if( index < GetRendererCount() )
+  {
+    renderer = ( *mRenderers )[ index ];
+  }

 
 

-  return attachment->GetRenderer();
+  return renderer;

 }
 
 void Actor::RemoveRenderer( Renderer& renderer )
 {
 }
 
 void Actor::RemoveRenderer( Renderer& renderer )
 {

-  //TODO: MESH_REWORK : Add support for multiple renderers
-  mAttachment = NULL;
+  if( mRenderers )
+  {
+    RendererIter end = mRenderers->end();
+    for( RendererIter iter = mRenderers->begin(); iter != end; ++iter )
+    {
+      if( (*iter).Get() == &renderer )
+      {
+        mRenderers->erase( iter );
+        RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+        break;
+      }
+    }
+  }

 }
 
 void Actor::RemoveRenderer( unsigned int index )
 {
 }
 
 void Actor::RemoveRenderer( unsigned int index )
 {

-  //TODO: MESH_REWORK : Add support for multiple renderers
-  mAttachment = NULL;
-}
-
-void Actor::SetOverlay( bool enable )
-{
-  // Setting STENCIL will override OVERLAY_2D
-  if( DrawMode::STENCIL != mDrawMode )
+  if( index < GetRendererCount() )

   {
   {

-    SetDrawMode( enable ? DrawMode::OVERLAY_2D : DrawMode::NORMAL );
+    RendererPtr renderer = ( *mRenderers )[ index ];
+    RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+    mRenderers->erase( mRenderers->begin()+index );

   }
 }
 
   }
 }
 


@@ -1421,7 +1622,7 @@ void Actor::SetDrawMode( DrawMode::Type drawMode )
 {
   // this flag is not animatable so keep the value
   mDrawMode = drawMode;
 {
   // this flag is not animatable so keep the value
   mDrawMode = drawMode;

-  if( NULL != mNode )
+  if( ( NULL != mNode ) && ( drawMode != DrawMode::STENCIL ) )

   {
     // mNode is being used in a separate thread; queue a message to set the value
     SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );
   {
     // mNode is being used in a separate thread; queue a message to set the value
     SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );


@@ -1458,7 +1659,7 @@ bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float sc
   return false;
 }
 
   return false;
 }
 

-bool Actor::ScreenToLocal( RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const
+bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& localY, float screenX, float screenY ) const

 {
   bool retval = false;
   // only valid when on-stage
 {
   bool retval = false;
   // only valid when on-stage


@@ -1489,13 +1690,9 @@ bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMat
     return false;
   }
 
     return false;
   }
 

-  BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-
-  // Calculate the ModelView matrix
-  Matrix modelView( false/*don't init*/);
-  // need to use the components as world matrix is only updated for actors that need it
-  modelView.SetTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
-  Matrix::Multiply( modelView, modelView, viewMatrix );
+  // Get the ModelView matrix
+  Matrix modelView;
+  Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix );

 
   // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
   Matrix invertedMvp( false/*don't init*/);
 
   // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
   Matrix invertedMvp( false/*don't init*/);


@@ -1628,21 +1825,19 @@ bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) con
   return ( b2 * b2 - a * c ) >= 0.f;
 }
 
   return ( b2 * b2 - a * c ) >= 0.f;
 }
 

-bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector4& hitPointLocal, float& distance ) const
+bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector2& hitPointLocal, float& distance ) const

 {
   bool hit = false;
 
 {
   bool hit = false;
 

-  if( OnStage() &&
-  NULL != mNode )
+  if( OnStage() && NULL != mNode )

   {
   {

-    BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-

     // Transforms the ray to the local reference system.
     // Transforms the ray to the local reference system.

-

     // Calculate the inverse of Model matrix
     Matrix invModelMatrix( false/*don't init*/);
     // Calculate the inverse of Model matrix
     Matrix invModelMatrix( false/*don't init*/);

-    // need to use the components as world matrix is only updated for actors that need it
-    invModelMatrix.SetInverseTransformComponents( mNode->GetWorldScale( bufferIndex ), mNode->GetWorldOrientation( bufferIndex ), mNode->GetWorldPosition( bufferIndex ) );
+
+    BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
+    invModelMatrix = mNode->GetWorldMatrix(0);
+    invModelMatrix.Invert();

 
     Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
     Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() );
 
     Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
     Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() );


@@ -1692,7 +1887,7 @@ bool Actor::IsKeyboardFocusable() const
 
 bool Actor::GetTouchRequired() const
 {
 
 bool Actor::GetTouchRequired() const
 {

-  return !mTouchedSignal.Empty() || mDerivedRequiresTouch;
+  return !mTouchedSignal.Empty() || !mTouchSignal.Empty() || mDerivedRequiresTouch;

 }
 
 bool Actor::GetHoverRequired() const
 }
 
 bool Actor::GetHoverRequired() const


@@ -1726,20 +1921,26 @@ bool Actor::IsGestureRequred( Gesture::Type type ) const
   return mGestureData && mGestureData->IsGestureRequred( type );
 }
 
   return mGestureData && mGestureData->IsGestureRequred( type );
 }
 

-bool Actor::EmitTouchEventSignal( const TouchEvent& event )
+bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData& touch )

 {
   bool consumed = false;
 
 {
   bool consumed = false;
 

+  if( !mTouchSignal.Empty() )
+  {
+    Dali::Actor handle( this );
+    consumed = mTouchSignal.Emit( handle, touch );
+  }
+

   if( !mTouchedSignal.Empty() )
   {
     Dali::Actor handle( this );
   if( !mTouchedSignal.Empty() )
   {
     Dali::Actor handle( this );

-    consumed = mTouchedSignal.Emit( handle, event );
+    consumed |= mTouchedSignal.Emit( handle, event );

   }
 
   if( !consumed )
   {
     // Notification for derived classes
   }
 
   if( !consumed )
   {
     // Notification for derived classes

-    consumed = OnTouchEvent( event );
+    consumed = OnTouchEvent( event ); // TODO

   }
 
   return consumed;
   }
 
   return consumed;


@@ -1783,11 +1984,34 @@ bool Actor::EmitWheelEventSignal( const WheelEvent& event )
   return consumed;
 }
 
   return consumed;
 }
 

+void Actor::EmitVisibilityChangedSignal( bool visible, DevelActor::VisibilityChange::Type type )
+{
+  if( ! mVisibilityChangedSignal.Empty() )
+  {
+    Dali::Actor handle( this );
+    mVisibilityChangedSignal.Emit( handle, visible, type );
+  }
+}
+
+void Actor::EmitLayoutDirectionChangedSignal( LayoutDirection::Type type )
+{
+  if( ! mLayoutDirectionChangedSignal.Empty() )
+  {
+    Dali::Actor handle( this );
+    mLayoutDirectionChangedSignal.Emit( handle, type );
+  }
+}
+

 Dali::Actor::TouchSignalType& Actor::TouchedSignal()
 {
   return mTouchedSignal;
 }
 
 Dali::Actor::TouchSignalType& Actor::TouchedSignal()
 {
   return mTouchedSignal;
 }
 

+Dali::Actor::TouchDataSignalType& Actor::TouchSignal()
+{
+  return mTouchSignal;
+}
+

 Dali::Actor::HoverSignalType& Actor::HoveredSignal()
 {
   return mHoveredSignal;
 Dali::Actor::HoverSignalType& Actor::HoveredSignal()
 {
   return mHoveredSignal;


@@ -1813,10 +2037,20 @@ Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
   return mOnRelayoutSignal;
 }
 
   return mOnRelayoutSignal;
 }
 

+DevelActor::VisibilityChangedSignalType& Actor::VisibilityChangedSignal()
+{
+  return mVisibilityChangedSignal;
+}
+
+Dali::Actor::LayoutDirectionChangedSignalType& Actor::LayoutDirectionChangedSignal()
+{
+  return mLayoutDirectionChangedSignal;
+}
+

 bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 {
   bool connected( true );
 bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 {
   bool connected( true );

-  Actor* actor = dynamic_cast< Actor* >( object );
+  Actor* actor = static_cast< Actor* >( object ); // TypeRegistry guarantees that this is the correct type.

 
   if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
   {
 
   if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
   {


@@ -1838,6 +2072,14 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
   {
     actor->OffStageSignal().Connect( tracker, functor );
   }
   {
     actor->OffStageSignal().Connect( tracker, functor );
   }

+  else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
+  {
+    actor->OnRelayoutSignal().Connect( tracker, functor );
+  }
+  else if( 0 == signalName.compare( SIGNAL_TOUCH ) )
+  {
+    actor->TouchSignal().Connect( tracker, functor );
+  }

   else
   {
     // signalName does not match any signal
   else
   {
     // signalName does not match any signal


@@ -1850,18 +2092,22 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
 Actor::Actor( DerivedType derivedType )
 : mParent( NULL ),
   mChildren( NULL ),
 Actor::Actor( DerivedType derivedType )
 : mParent( NULL ),
   mChildren( NULL ),

+  mRenderers( NULL ),

   mNode( NULL ),
   mParentOrigin( NULL ),
   mAnchorPoint( NULL ),
   mRelayoutData( NULL ),
   mGestureData( NULL ),
   mNode( NULL ),
   mParentOrigin( NULL ),
   mAnchorPoint( NULL ),
   mRelayoutData( NULL ),
   mGestureData( NULL ),

-  mAttachment(),
-  mTargetSize( 0.0f, 0.0f, 0.0f ),
+  mTargetOrientation( Quaternion::IDENTITY ),
+  mTargetColor( Color::WHITE ),
+  mTargetSize( Vector3::ZERO ),
+  mTargetPosition( Vector3::ZERO ),
+  mTargetScale( Vector3::ONE ),

   mName(),
   mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
   mName(),
   mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved

+  mSortedDepth( 0u ),

   mDepth( 0u ),
   mIsRoot( ROOT_LAYER == derivedType ),
   mDepth( 0u ),
   mIsRoot( ROOT_LAYER == derivedType ),

-  mIsRenderable( RENDERABLE == derivedType ),

   mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
   mIsOnStage( false ),
   mSensitive( true ),
   mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
   mIsOnStage( false ),
   mSensitive( true ),


@@ -1872,21 +2118,26 @@ Actor::Actor( DerivedType derivedType )
   mDerivedRequiresWheelEvent( false ),
   mOnStageSignalled( false ),
   mInsideOnSizeSet( false ),
   mDerivedRequiresWheelEvent( false ),
   mOnStageSignalled( false ),
   mInsideOnSizeSet( false ),

+  mInheritPosition( true ),

   mInheritOrientation( true ),
   mInheritScale( true ),
   mInheritOrientation( true ),
   mInheritScale( true ),

+  mPositionUsesAnchorPoint( true ),
+  mVisible( true ),
+  mInheritLayoutDirection( true ),
+  mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),

   mDrawMode( DrawMode::NORMAL ),
   mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
   mDrawMode( DrawMode::NORMAL ),
   mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),

-  mColorMode( Node::DEFAULT_COLOR_MODE )
+  mColorMode( Node::DEFAULT_COLOR_MODE ),
+  mClippingMode( ClippingMode::DISABLED )

 {
 }
 
 void Actor::Initialize()
 {
 {
 }
 
 void Actor::Initialize()
 {

-  // Node creation
-  SceneGraph::Node* node = CreateNode();
-
-  AddNodeMessage( GetEventThreadServices().GetUpdateManager(), *node ); // Pass ownership to scene-graph
-  mNode = node; // Keep raw-pointer to Node
+  // Node creation, keep raw-pointer to Node for messaging
+  mNode = CreateNode();
+  OwnerPointer< SceneGraph::Node > transferOwnership( const_cast< SceneGraph::Node* >( mNode ) );
+  AddNodeMessage( GetEventThreadServices().GetUpdateManager(), transferOwnership );

 
   OnInitialize();
 
 
   OnInitialize();
 


@@ -1906,6 +2157,7 @@ Actor::~Actor()
     }
   }
   delete mChildren;
     }
   }
   delete mChildren;

+  delete mRenderers;

 
   // Guard to allow handle destruction after Core has been destroyed
   if( EventThreadServices::IsCoreRunning() )
 
   // Guard to allow handle destruction after Core has been destroyed
   if( EventThreadServices::IsCoreRunning() )


@@ -1939,6 +2191,12 @@ void Actor::ConnectToStage( unsigned int parentDepth )
   // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
   ActorContainer connectionList;
 
   // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
   ActorContainer connectionList;
 

+  StagePtr stage = Stage::GetCurrent();
+  if( stage )
+  {
+    stage->RequestRebuildDepthTree();
+  }
+

   // This stage is atomic i.e. not interrupted by user callbacks.
   RecursiveConnectToStage( connectionList, parentDepth + 1 );
 
   // This stage is atomic i.e. not interrupted by user callbacks.
   RecursiveConnectToStage( connectionList, parentDepth + 1 );
 


@@ -1994,12 +2252,6 @@ void Actor::ConnectToSceneGraph()
     ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
   }
 
     ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
   }
 

-  // Notify attachment
-  if( mAttachment )
-  {
-    mAttachment->Connect();
-  }
-

   // Request relayout on all actors that are added to the scenegraph
   RelayoutRequest();
 
   // Request relayout on all actors that are added to the scenegraph
   RelayoutRequest();
 


@@ -2036,6 +2288,12 @@ void Actor::DisconnectFromStage()
   // It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
   ActorContainer disconnectionList;
 
   // It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
   ActorContainer disconnectionList;
 

+  StagePtr stage = Stage::GetCurrent();
+  if( stage )
+  {
+    stage->RequestRebuildDepthTree();
+  }
+

   // This stage is atomic i.e. not interrupted by user callbacks
   RecursiveDisconnectFromStage( disconnectionList );
 
   // This stage is atomic i.e. not interrupted by user callbacks
   RecursiveDisconnectFromStage( disconnectionList );
 


@@ -2080,12 +2338,6 @@ void Actor::DisconnectFromSceneGraph()
 {
   // Notification for Object::Observers
   OnSceneObjectRemove();
 {
   // Notification for Object::Observers
   OnSceneObjectRemove();

-
-  // Notify attachment
-  if( mAttachment )
-  {
-    mAttachment->Disconnect();
-  }

 }
 
 void Actor::NotifyStageDisconnection()
 }
 
 void Actor::NotifyStageDisconnection()


@@ -2116,10 +2368,9 @@ bool Actor::IsNodeConnected() const
 {
   bool connected( false );
 
 {
   bool connected( false );
 

-  if( OnStage() &&
-  NULL != mNode )
+  if( OnStage() && ( NULL != mNode ) )

   {
   {

-    if( mNode->IsRoot() || mNode->GetParent() )
+    if( IsRoot() || mNode->GetParent() )

     {
       connected = true;
     }
     {
       connected = true;
     }


@@ -2128,6 +2379,44 @@ bool Actor::IsNodeConnected() const
   return connected;
 }
 
   return connected;
 }
 

+// This method initiates traversal of the actor tree using depth-first
+// traversal to set a depth index based on traversal order. It sends a
+// single message to update manager to update all the actor's nodes in
+// this tree with the depth index. The sceneGraphNodeDepths vector's
+// elements are ordered by depth, and could be used to reduce sorting
+// in the update thread.
+void Actor::RebuildDepthTree()
+{
+  DALI_LOG_TIMER_START(depthTimer);
+
+  // Vector of scene-graph nodes and their depths to send to UpdateManager
+  // in a single message
+  OwnerPointer<SceneGraph::NodeDepths> sceneGraphNodeDepths( new SceneGraph::NodeDepths() );
+
+  int depthIndex = 1;
+  DepthTraverseActorTree( sceneGraphNodeDepths, depthIndex );
+
+  SetDepthIndicesMessage( GetEventThreadServices().GetUpdateManager(), sceneGraphNodeDepths );
+  DALI_LOG_TIMER_END(depthTimer, gLogFilter, Debug::Concise, "Depth tree traversal time: ");
+}
+
+void Actor::DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int& depthIndex )
+{
+  mSortedDepth = depthIndex * DevelLayer::SIBLING_ORDER_MULTIPLIER;
+  sceneGraphNodeDepths->Add( const_cast<SceneGraph::Node*>( mNode ), mSortedDepth );
+
+  // Create/add to children of this node
+  if( mChildren )
+  {
+    for( ActorContainer::iterator it = mChildren->begin(); it != mChildren->end(); ++it )
+    {
+      Actor* childActor = (*it).Get();
+      ++depthIndex;
+      childActor->DepthTraverseActorTree( sceneGraphNodeDepths, depthIndex );
+    }
+  }
+}
+

 unsigned int Actor::GetDefaultPropertyCount() const
 {
   return DEFAULT_PROPERTY_COUNT;
 unsigned int Actor::GetDefaultPropertyCount() const
 {
   return DEFAULT_PROPERTY_COUNT;


@@ -2218,8 +2507,22 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
   {
     case Dali::Actor::Property::PARENT_ORIGIN:
     {
   {
     case Dali::Actor::Property::PARENT_ORIGIN:
     {

-      SetParentOrigin( property.Get< Vector3 >() );
-      break;
+      Property::Type type = property.GetType();
+      if( type == Property::VECTOR3 )
+      {
+        SetParentOrigin( property.Get< Vector3 >() );
+      }
+      else if ( type == Property::STRING )
+      {
+        std::string parentOriginString;
+        property.Get( parentOriginString );
+        Vector3 parentOrigin;
+        if( GetParentOriginConstant( parentOriginString, parentOrigin ) )
+        {
+          SetParentOrigin( parentOrigin );
+        }
+      }
+      break;

     }
 
     case Dali::Actor::Property::PARENT_ORIGIN_X:
     }
 
     case Dali::Actor::Property::PARENT_ORIGIN_X:


@@ -2242,7 +2545,21 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::ANCHOR_POINT:
     {
 
     case Dali::Actor::Property::ANCHOR_POINT:
     {

-      SetAnchorPoint( property.Get< Vector3 >() );
+      Property::Type type = property.GetType();
+      if( type == Property::VECTOR3 )
+      {
+        SetAnchorPoint( property.Get< Vector3 >() );
+      }
+      else if ( type == Property::STRING )
+      {
+        std::string anchorPointString;
+        property.Get( anchorPointString );
+        Vector3 anchor;
+        if( GetAnchorPointConstant( anchorPointString, anchor ) )
+        {
+          SetAnchorPoint( anchor );
+        }
+      }

       break;
     }
 
       break;
     }
 


@@ -2373,8 +2690,13 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
     }
 
     case Dali::Actor::Property::COLOR_ALPHA:
     }
 
     case Dali::Actor::Property::COLOR_ALPHA:

+    case Dali::DevelActor::Property::OPACITY:

     {
     {

-      SetOpacity( property.Get< float >() );
+      float value;
+      if( property.Get( value ) )
+      {
+        SetOpacity( value );
+      }

       break;
     }
 
       break;
     }
 


@@ -2396,6 +2718,12 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
       break;
     }
 
       break;
     }
 

+    case Dali::Actor::Property::INHERIT_POSITION:
+    {
+      SetInheritPosition( property.Get< bool >() );
+      break;
+    }
+

     case Dali::Actor::Property::INHERIT_ORIENTATION:
     {
       SetInheritOrientation( property.Get< bool >() );
     case Dali::Actor::Property::INHERIT_ORIENTATION:
     {
       SetInheritOrientation( property.Get< bool >() );


@@ -2410,19 +2738,31 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::COLOR_MODE:
     {
 
     case Dali::Actor::Property::COLOR_MODE:
     {

-      SetColorMode( Scripting::GetColorMode( property.Get< std::string >() ) );
+      ColorMode mode = mColorMode;
+      if ( Scripting::GetEnumerationProperty< ColorMode >( property, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode ) )
+      {
+        SetColorMode( mode );
+      }

       break;
     }
 
     case Dali::Actor::Property::POSITION_INHERITANCE:
     {
       break;
     }
 
     case Dali::Actor::Property::POSITION_INHERITANCE:
     {

-      SetPositionInheritanceMode( Scripting::GetPositionInheritanceMode( property.Get< std::string >() ) );
+      PositionInheritanceMode mode = mPositionInheritanceMode;
+      if( Scripting::GetEnumerationProperty< PositionInheritanceMode >( property, POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT, mode ) )
+      {
+        SetPositionInheritanceMode( mode );
+      }

       break;
     }
 
     case Dali::Actor::Property::DRAW_MODE:
     {
       break;
     }
 
     case Dali::Actor::Property::DRAW_MODE:
     {

-      SetDrawMode( Scripting::GetDrawMode( property.Get< std::string >() ) );
+      DrawMode::Type mode = mDrawMode;
+      if( Scripting::GetEnumerationProperty< DrawMode::Type >( property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
+      {
+        SetDrawMode( mode );
+      }

       break;
     }
 
       break;
     }
 


@@ -2434,8 +2774,8 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
     {
 
     case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
     {

-      ResizePolicy::Type type;
-      if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) )
+      ResizePolicy::Type type = static_cast< ResizePolicy::Type >( -1 ); // Set to invalid number so it definitely gets set.
+      if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )

       {
         SetResizePolicy( type, Dimension::WIDTH );
       }
       {
         SetResizePolicy( type, Dimension::WIDTH );
       }


@@ -2444,8 +2784,8 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
     {
 
     case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
     {

-      ResizePolicy::Type type;
-      if( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount, type ) )
+      ResizePolicy::Type type = static_cast< ResizePolicy::Type >( -1 ); // Set to invalid number so it definitely gets set.
+      if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )

       {
         SetResizePolicy( type, Dimension::HEIGHT );
       }
       {
         SetResizePolicy( type, Dimension::HEIGHT );
       }


@@ -2455,7 +2795,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
     case Dali::Actor::Property::SIZE_SCALE_POLICY:
     {
       SizeScalePolicy::Type type;
     case Dali::Actor::Property::SIZE_SCALE_POLICY:
     {
       SizeScalePolicy::Type type;

-      if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount, type ) )
+      if( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )

       {
         SetSizeScalePolicy( type );
       }
       {
         SetSizeScalePolicy( type );
       }


@@ -2504,6 +2844,67 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
       break;
     }
 
       break;
     }
 

+    case Dali::DevelActor::Property::SIBLING_ORDER:
+    {
+      int value;
+
+      if( property.Get( value ) )
+      {
+        SetSiblingOrder( value );
+      }
+      break;
+    }
+
+    case Dali::Actor::Property::CLIPPING_MODE:
+    {
+      ClippingMode::Type convertedValue = mClippingMode;
+      if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
+      {
+        mClippingMode = convertedValue;
+        if( NULL != mNode )
+        {
+          SetClippingModeMessage( GetEventThreadServices(), *mNode, mClippingMode );
+        }
+      }
+      break;
+    }
+
+    case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+    {
+      bool value = false;
+      if( property.Get( value ) && value != mPositionUsesAnchorPoint )
+      {
+        mPositionUsesAnchorPoint = value;
+        if( NULL != mNode )
+        {
+          SetPositionUsesAnchorPointMessage( GetEventThreadServices(), *mNode, mPositionUsesAnchorPoint );
+        }
+      }
+      break;
+    }
+
+    case Dali::Actor::Property::LAYOUT_DIRECTION:
+    {
+      Dali::LayoutDirection::Type direction = mLayoutDirection;
+      mInheritLayoutDirection = false;
+
+      if( Scripting::GetEnumerationProperty< LayoutDirection::Type >( property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction ) )
+      {
+        InheritLayoutDirectionRecursively( this, direction, true );
+      }
+      break;
+    }
+
+    case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+    {
+      bool value = false;
+      if( property.Get( value ) )
+      {
+        SetInheritLayoutDirection( value );
+      }
+      break;
+    }
+

     default:
     {
       // this can happen in the case of a non-animatable default property so just do nothing
     default:
     {
       // this can happen in the case of a non-animatable default property so just do nothing


@@ -2515,7 +2916,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 // TODO: This method needs to be removed
 void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
 {
 // TODO: This method needs to be removed
 void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
 {

-  switch( entry.type )
+  switch( entry.GetType() )

   {
     case Property::BOOLEAN:
     {
   {
     case Property::BOOLEAN:
     {


@@ -2663,340 +3064,339 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
 
     default:
     {
 
     default:
     {

-      DALI_ASSERT_ALWAYS( false && "Property type enumeration out of bounds" ); // should not come here
-      break;
+      // nothing to do for other types

     }
     }

-  }
+  } // entry.GetType

 }
 
 Property::Value Actor::GetDefaultProperty( Property::Index index ) const
 {
   Property::Value value;
 
 }
 
 Property::Value Actor::GetDefaultProperty( Property::Index index ) const
 {
   Property::Value value;
 

-  switch( index )
+  if( ! GetCachedPropertyValue( index, value ) )

   {
   {

-    case Dali::Actor::Property::PARENT_ORIGIN:
-    {
-      value = GetCurrentParentOrigin();
-      break;
-    }
+    // If property value is not stored in the event-side, then it must be a scene-graph only property
+    GetCurrentPropertyValue( index, value );
+  }

 
 

-    case Dali::Actor::Property::PARENT_ORIGIN_X:
-    {
-      value = GetCurrentParentOrigin().x;
-      break;
-    }
+  return value;
+}

 
 

-    case Dali::Actor::Property::PARENT_ORIGIN_Y:
-    {
-      value = GetCurrentParentOrigin().y;
-      break;
-    }
+Property::Value Actor::GetDefaultPropertyCurrentValue( Property::Index index ) const
+{
+  Property::Value value;

 
 

-    case Dali::Actor::Property::PARENT_ORIGIN_Z:
-    {
-      value = GetCurrentParentOrigin().z;
-      break;
-    }
+  if( ! GetCurrentPropertyValue( index, value ) )
+  {
+    // If unable to retrieve scene-graph property value, then it must be an event-side only property
+    GetCachedPropertyValue( index, value );
+  }

 
 

-    case Dali::Actor::Property::ANCHOR_POINT:
-    {
-      value = GetCurrentAnchorPoint();
-      break;
-    }
+  return value;
+}

 
 

-    case Dali::Actor::Property::ANCHOR_POINT_X:
+void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType )
+{
+  switch( animationType )
+  {
+    case Animation::TO:
+    case Animation::BETWEEN:

     {
     {

-      value = GetCurrentAnchorPoint().x;
-      break;
-    }
+      switch( index )
+      {
+        case Dali::Actor::Property::SIZE:
+        {
+          if( value.Get( mTargetSize ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::ANCHOR_POINT_Y:
-    {
-      value = GetCurrentAnchorPoint().y;
-      break;
-    }
+        case Dali::Actor::Property::SIZE_WIDTH:
+        {
+          if( value.Get( mTargetSize.width ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::ANCHOR_POINT_Z:
-    {
-      value = GetCurrentAnchorPoint().z;
-      break;
-    }
+        case Dali::Actor::Property::SIZE_HEIGHT:
+        {
+          if( value.Get( mTargetSize.height ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::SIZE:
-    {
-      value = GetCurrentSize();
-      break;
-    }
+        case Dali::Actor::Property::SIZE_DEPTH:
+        {
+          if( value.Get( mTargetSize.depth ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::SIZE_WIDTH:
-    {
-      value = GetCurrentSize().width;
-      break;
-    }
+        case Dali::Actor::Property::POSITION:
+        {
+          value.Get( mTargetPosition );
+          break;
+        }

 
 

-    case Dali::Actor::Property::SIZE_HEIGHT:
-    {
-      value = GetCurrentSize().height;
-      break;
-    }
+        case Dali::Actor::Property::POSITION_X:
+        {
+          value.Get( mTargetPosition.x );
+          break;
+        }

 
 

-    case Dali::Actor::Property::SIZE_DEPTH:
-    {
-      value = GetCurrentSize().depth;
-      break;
-    }
+        case Dali::Actor::Property::POSITION_Y:
+        {
+          value.Get( mTargetPosition.y );
+          break;
+        }

 
 

-    case Dali::Actor::Property::POSITION:
-    {
-      value = GetCurrentPosition();
-      break;
-    }
+        case Dali::Actor::Property::POSITION_Z:
+        {
+          value.Get( mTargetPosition.z );
+          break;
+        }

 
 

-    case Dali::Actor::Property::POSITION_X:
-    {
-      value = GetCurrentPosition().x;
-      break;
-    }
+        case Dali::Actor::Property::ORIENTATION:
+        {
+          value.Get( mTargetOrientation );
+          break;
+        }

 
 

-    case Dali::Actor::Property::POSITION_Y:
-    {
-      value = GetCurrentPosition().y;
-      break;
-    }
+        case Dali::Actor::Property::SCALE:
+        {
+          value.Get( mTargetScale );
+          break;
+        }

 
 

-    case Dali::Actor::Property::POSITION_Z:
-    {
-      value = GetCurrentPosition().z;
-      break;
-    }
+        case Dali::Actor::Property::SCALE_X:
+        {
+          value.Get( mTargetScale.x );
+          break;
+        }

 
 

-    case Dali::Actor::Property::WORLD_POSITION:
-    {
-      value = GetCurrentWorldPosition();
-      break;
-    }
+        case Dali::Actor::Property::SCALE_Y:
+        {
+          value.Get( mTargetScale.y );
+          break;
+        }

 
 

-    case Dali::Actor::Property::WORLD_POSITION_X:
-    {
-      value = GetCurrentWorldPosition().x;
-      break;
-    }
+        case Dali::Actor::Property::SCALE_Z:
+        {
+          value.Get( mTargetScale.z );
+          break;
+        }

 
 

-    case Dali::Actor::Property::WORLD_POSITION_Y:
-    {
-      value = GetCurrentWorldPosition().y;
-      break;
-    }
+        case Dali::Actor::Property::VISIBLE:
+        {
+          SetVisibleInternal( value.Get< bool >(), SendMessage::FALSE );
+          break;
+        }

 
 

-    case Dali::Actor::Property::WORLD_POSITION_Z:
-    {
-      value = GetCurrentWorldPosition().z;
-      break;
-    }
+        case Dali::Actor::Property::COLOR:
+        {
+          value.Get( mTargetColor );
+          break;
+        }

 
 

-    case Dali::Actor::Property::ORIENTATION:
-    {
-      value = GetCurrentOrientation();
-      break;
-    }
+        case Dali::Actor::Property::COLOR_RED:
+        {
+          value.Get( mTargetColor.r );
+          break;
+        }

 
 

-    case Dali::Actor::Property::WORLD_ORIENTATION:
-    {
-      value = GetCurrentWorldOrientation();
+        case Dali::Actor::Property::COLOR_GREEN:
+        {
+          value.Get( mTargetColor.g );
+          break;
+        }
+
+        case Dali::Actor::Property::COLOR_BLUE:
+        {
+          value.Get( mTargetColor.b );
+          break;
+        }
+
+        case Dali::Actor::Property::COLOR_ALPHA:
+        case Dali::DevelActor::Property::OPACITY:
+        {
+          value.Get( mTargetColor.a );
+          break;
+        }
+
+        default:
+        {
+          // Not an animatable property. Do nothing.
+          break;
+        }
+      }

       break;
     }
 
       break;
     }
 

-    case Dali::Actor::Property::SCALE:
-    {
-      value = GetCurrentScale();
-      break;
-    }
-
-    case Dali::Actor::Property::SCALE_X:
-    {
-      value = GetCurrentScale().x;
-      break;
-    }
-
-    case Dali::Actor::Property::SCALE_Y:
-    {
-      value = GetCurrentScale().y;
-      break;
-    }
-
-    case Dali::Actor::Property::SCALE_Z:
-    {
-      value = GetCurrentScale().z;
-      break;
-    }
-
-    case Dali::Actor::Property::WORLD_SCALE:
-    {
-      value = GetCurrentWorldScale();
-      break;
-    }
-
-    case Dali::Actor::Property::VISIBLE:
-    {
-      value = IsVisible();
-      break;
-    }
-
-    case Dali::Actor::Property::COLOR:
-    {
-      value = GetCurrentColor();
-      break;
-    }
-
-    case Dali::Actor::Property::COLOR_RED:
-    {
-      value = GetCurrentColor().r;
-      break;
-    }
-
-    case Dali::Actor::Property::COLOR_GREEN:
-    {
-      value = GetCurrentColor().g;
-      break;
-    }
-
-    case Dali::Actor::Property::COLOR_BLUE:
-    {
-      value = GetCurrentColor().b;
-      break;
-    }
-
-    case Dali::Actor::Property::COLOR_ALPHA:
-    {
-      value = GetCurrentColor().a;
-      break;
-    }
-
-    case Dali::Actor::Property::WORLD_COLOR:
+    case Animation::BY:

     {
     {

-      value = GetCurrentWorldColor();
-      break;
-    }
+      switch( index )
+      {
+        case Dali::Actor::Property::SIZE:
+        {
+          if( AdjustValue< Vector3 >( mTargetSize, value ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::WORLD_MATRIX:
-    {
-      value = GetCurrentWorldMatrix();
-      break;
-    }
+        case Dali::Actor::Property::SIZE_WIDTH:
+        {
+          if( AdjustValue< float >( mTargetSize.width, value ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::NAME:
-    {
-      value = GetName();
-      break;
-    }
+        case Dali::Actor::Property::SIZE_HEIGHT:
+        {
+          if( AdjustValue< float >( mTargetSize.height, value ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::SENSITIVE:
-    {
-      value = IsSensitive();
-      break;
-    }
+        case Dali::Actor::Property::SIZE_DEPTH:
+        {
+          if( AdjustValue< float >( mTargetSize.depth, value ) )
+          {
+            // Notify deriving classes
+            OnSizeAnimation( animation, mTargetSize );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::LEAVE_REQUIRED:
-    {
-      value = GetLeaveRequired();
-      break;
-    }
+        case Dali::Actor::Property::POSITION:
+        {
+          AdjustValue< Vector3 >( mTargetPosition, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::INHERIT_ORIENTATION:
-    {
-      value = IsOrientationInherited();
-      break;
-    }
+        case Dali::Actor::Property::POSITION_X:
+        {
+          AdjustValue< float >( mTargetPosition.x, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::INHERIT_SCALE:
-    {
-      value = IsScaleInherited();
-      break;
-    }
+        case Dali::Actor::Property::POSITION_Y:
+        {
+          AdjustValue< float >( mTargetPosition.y, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::COLOR_MODE:
-    {
-      value = Scripting::GetColorMode( GetColorMode() );
-      break;
-    }
+        case Dali::Actor::Property::POSITION_Z:
+        {
+          AdjustValue< float >( mTargetPosition.z, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::POSITION_INHERITANCE:
-    {
-      value = Scripting::GetPositionInheritanceMode( GetPositionInheritanceMode() );
-      break;
-    }
+        case Dali::Actor::Property::ORIENTATION:
+        {
+          Quaternion relativeValue;
+          if( value.Get( relativeValue ) )
+          {
+            mTargetOrientation *= relativeValue;
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::DRAW_MODE:
-    {
-      value = Scripting::GetDrawMode( GetDrawMode() );
-      break;
-    }
+        case Dali::Actor::Property::SCALE:
+        {
+          AdjustValue< Vector3 >( mTargetScale, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::SIZE_MODE_FACTOR:
-    {
-      value = GetSizeModeFactor();
-      break;
-    }
+        case Dali::Actor::Property::SCALE_X:
+        {
+          AdjustValue< float >( mTargetScale.x, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
-    {
-      value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
-      break;
-    }
+        case Dali::Actor::Property::SCALE_Y:
+        {
+          AdjustValue< float >( mTargetScale.y, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
-    {
-      value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
-      break;
-    }
+        case Dali::Actor::Property::SCALE_Z:
+        {
+          AdjustValue< float >( mTargetScale.z, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::SIZE_SCALE_POLICY:
-    {
-      value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount );
-      break;
-    }
+        case Dali::Actor::Property::VISIBLE:
+        {
+          bool relativeValue = false;
+          if( value.Get( relativeValue ) )
+          {
+            bool visible = mVisible || relativeValue;
+            SetVisibleInternal( visible, SendMessage::FALSE );
+          }
+          break;
+        }

 
 

-    case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
-    {
-      value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
-      break;
-    }
+        case Dali::Actor::Property::COLOR:
+        {
+          AdjustValue< Vector4 >( mTargetColor, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
-    {
-      value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
-      break;
-    }
+        case Dali::Actor::Property::COLOR_RED:
+        {
+          AdjustValue< float >( mTargetColor.r, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::PADDING:
-    {
-      Vector2 widthPadding = GetPadding( Dimension::WIDTH );
-      Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
-      value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
-      break;
-    }
+        case Dali::Actor::Property::COLOR_GREEN:
+        {
+          AdjustValue< float >( mTargetColor.g, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::MINIMUM_SIZE:
-    {
-      value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
-      break;
-    }
+        case Dali::Actor::Property::COLOR_BLUE:
+        {
+          AdjustValue< float >( mTargetColor.b, value );
+          break;
+        }

 
 

-    case Dali::Actor::Property::MAXIMUM_SIZE:
-    {
-      value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
-      break;
-    }
+        case Dali::Actor::Property::COLOR_ALPHA:
+        case Dali::DevelActor::Property::OPACITY:
+        {
+          AdjustValue< float >( mTargetColor.a, value );
+          break;
+        }

 
 

-    default:
-    {
-      DALI_ASSERT_ALWAYS( false && "Actor Property index invalid" ); // should not come here
+        default:
+        {
+          // Not an animatable property. Do nothing.
+          break;
+        }
+      }

       break;
     }
   }
       break;
     }
   }

-
-  return value;

 }
 
 const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
 }
 
 const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const


@@ -3029,7 +3429,8 @@ const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index ind
 
     property = animatable->GetSceneGraphProperty();
   }
 
     property = animatable->GetSceneGraphProperty();
   }

-  else if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
+  else if ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && // Child properties are also stored as custom properties
+            ( index <= PROPERTY_CUSTOM_MAX_INDEX ) )

   {
     CustomPropertyMetadata* custom = FindCustomProperty( index );
     DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
   {
     CustomPropertyMetadata* custom = FindCustomProperty( index );
     DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );


@@ -3113,6 +3514,7 @@ const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index ind
         break;
 
       case Dali::Actor::Property::COLOR_ALPHA:
         break;
 
       case Dali::Actor::Property::COLOR_ALPHA:

+      case Dali::DevelActor::Property::OPACITY:

         property = &mNode->mColor;
         break;
 
         property = &mNode->mColor;
         break;
 


@@ -3141,7 +3543,8 @@ const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index ind
 
     property = animatable->GetSceneGraphProperty();
   }
 
     property = animatable->GetSceneGraphProperty();
   }

-  else if ( index >= DEFAULT_PROPERTY_MAX_COUNT )
+  else if ( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && // Child properties are also stored as custom properties
+            ( index <= PROPERTY_CUSTOM_MAX_INDEX ) )

   {
     CustomPropertyMetadata* custom = FindCustomProperty( index );
     DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );
   {
     CustomPropertyMetadata* custom = FindCustomProperty( index );
     DALI_ASSERT_ALWAYS( custom && "Property index is invalid" );


@@ -3280,8 +3683,11 @@ const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index ind
         break;
 
       case Dali::Actor::Property::COLOR_ALPHA:
         break;
 
       case Dali::Actor::Property::COLOR_ALPHA:

+      case Dali::DevelActor::Property::OPACITY:
+      {

         property = &mNode->mColor;
         break;
         property = &mNode->mColor;
         break;

+      }

 
       case Dali::Actor::Property::WORLD_COLOR:
         property = &mNode->mWorldColor;
 
       case Dali::Actor::Property::WORLD_COLOR:
         property = &mNode->mWorldColor;


@@ -3353,6 +3759,7 @@ int Actor::GetPropertyComponentIndex( Property::Index index ) const
       }
 
       case Dali::Actor::Property::COLOR_ALPHA:
       }
 
       case Dali::Actor::Property::COLOR_ALPHA:

+      case Dali::DevelActor::Property::OPACITY:

       {
         componentIndex = 3;
         break;
       {
         componentIndex = 3;
         break;


@@ -3383,6 +3790,9 @@ void Actor::SetParent( Actor* parent )
       // Instruct each actor to create a corresponding node in the scene graph
       ConnectToStage( parent->GetHierarchyDepth() );
     }
       // Instruct each actor to create a corresponding node in the scene graph
       ConnectToStage( parent->GetHierarchyDepth() );
     }

+
+    // Resolve the name and index for the child properties if any
+    ResolveChildProperties();

   }
   else // parent being set to NULL
   {
   }
   else // parent being set to NULL
   {


@@ -3390,48 +3800,554 @@ void Actor::SetParent( Actor* parent )
 
     mParent = NULL;
 
 
     mParent = NULL;
 

-    if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
-         OnStage() )
+    if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
+         OnStage() )
+    {
+      DALI_ASSERT_ALWAYS( mNode != NULL );
+
+      if( NULL != mNode )
+      {
+        // Disconnect the Node & its children from the scene-graph.
+        DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
+      }
+
+      // Instruct each actor to discard pointers to the scene-graph
+      DisconnectFromStage();
+    }
+  }
+}
+
+SceneGraph::Node* Actor::CreateNode() const
+{
+  return Node::New();
+}
+
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
+{
+  bool done = false;
+  Actor* actor = dynamic_cast< Actor* >( object );
+
+  if( actor )
+  {
+    if( 0 == actionName.compare( ACTION_SHOW ) )
+    {
+      actor->SetVisible( true );
+      done = true;
+    }
+    else if( 0 == actionName.compare( ACTION_HIDE ) )
+    {
+      actor->SetVisible( false );
+      done = true;
+    }
+  }
+
+  return done;
+}
+
+bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
+{
+  bool valueSet = true;
+
+  switch( index )
+  {
+    case Dali::Actor::Property::PARENT_ORIGIN:
+    {
+      value = GetCurrentParentOrigin();
+      break;
+    }
+
+    case Dali::Actor::Property::PARENT_ORIGIN_X:
+    {
+      value = GetCurrentParentOrigin().x;
+      break;
+    }
+
+    case Dali::Actor::Property::PARENT_ORIGIN_Y:
+    {
+      value = GetCurrentParentOrigin().y;
+      break;
+    }
+
+    case Dali::Actor::Property::PARENT_ORIGIN_Z:
+    {
+      value = GetCurrentParentOrigin().z;
+      break;
+    }
+
+    case Dali::Actor::Property::ANCHOR_POINT:
+    {
+      value = GetCurrentAnchorPoint();
+      break;
+    }
+
+    case Dali::Actor::Property::ANCHOR_POINT_X:
+    {
+      value = GetCurrentAnchorPoint().x;
+      break;
+    }
+
+    case Dali::Actor::Property::ANCHOR_POINT_Y:
+    {
+      value = GetCurrentAnchorPoint().y;
+      break;
+    }
+
+    case Dali::Actor::Property::ANCHOR_POINT_Z:
+    {
+      value = GetCurrentAnchorPoint().z;
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE:
+    {
+      value = GetTargetSize();
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_WIDTH:
+    {
+      value = GetTargetSize().width;
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_HEIGHT:
+    {
+      value = GetTargetSize().height;
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_DEPTH:
+    {
+      value = GetTargetSize().depth;
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION:
+    {
+      value = GetTargetPosition();
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_X:
+    {
+      value = GetTargetPosition().x;
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_Y:
+    {
+      value = GetTargetPosition().y;
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_Z:
+    {
+      value = GetTargetPosition().z;
+      break;
+    }
+
+    case Dali::Actor::Property::ORIENTATION:
+    {
+      value = mTargetOrientation;
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE:
+    {
+      value = mTargetScale;
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE_X:
+    {
+      value = mTargetScale.x;
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE_Y:
+    {
+      value = mTargetScale.y;
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE_Z:
+    {
+      value = mTargetScale.z;
+      break;
+    }
+
+    case Dali::Actor::Property::VISIBLE:
+    {
+      value = mVisible;
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR:
+    {
+      value = mTargetColor;
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_RED:
+    {
+      value = mTargetColor.r;
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_GREEN:
+    {
+      value = mTargetColor.g;
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_BLUE:
+    {
+      value = mTargetColor.b;
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_ALPHA:
+    case Dali::DevelActor::Property::OPACITY:
+    {
+      value = mTargetColor.a;
+      break;
+    }
+
+    case Dali::Actor::Property::NAME:
+    {
+      value = GetName();
+      break;
+    }
+
+    case Dali::Actor::Property::SENSITIVE:
+    {
+      value = IsSensitive();
+      break;
+    }
+
+    case Dali::Actor::Property::LEAVE_REQUIRED:
+    {
+      value = GetLeaveRequired();
+      break;
+    }
+
+    case Dali::Actor::Property::INHERIT_POSITION:
+    {
+      value = IsPositionInherited();
+      break;
+    }
+
+    case Dali::Actor::Property::INHERIT_ORIENTATION:
+    {
+      value = IsOrientationInherited();
+      break;
+    }
+
+    case Dali::Actor::Property::INHERIT_SCALE:
+    {
+      value = IsScaleInherited();
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_MODE:
+    {
+      value = Scripting::GetLinearEnumerationName< ColorMode >( GetColorMode(), COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT );
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_INHERITANCE:
+    {
+      value = Scripting::GetLinearEnumerationName< PositionInheritanceMode >( GetPositionInheritanceMode(), POSITION_INHERITANCE_MODE_TABLE, POSITION_INHERITANCE_MODE_TABLE_COUNT );
+      break;
+    }
+
+    case Dali::Actor::Property::DRAW_MODE:
+    {
+      value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_MODE_FACTOR:
+    {
+      value = GetSizeModeFactor();
+      break;
+    }
+
+    case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
+    {
+      value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+      break;
+    }
+
+    case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
+    {
+      value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_SCALE_POLICY:
+    {
+      value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT );
+      break;
+    }
+
+    case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
+    {
+      value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
+      break;
+    }
+
+    case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
+    {
+      value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
+      break;
+    }
+
+    case Dali::Actor::Property::PADDING:
+    {
+      Vector2 widthPadding = GetPadding( Dimension::WIDTH );
+      Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
+      value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
+      break;
+    }
+
+    case Dali::Actor::Property::MINIMUM_SIZE:
+    {
+      value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
+      break;
+    }
+
+    case Dali::Actor::Property::MAXIMUM_SIZE:
+    {
+      value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
+      break;
+    }
+
+    case Dali::Actor::Property::CLIPPING_MODE:
+    {
+      value = mClippingMode;
+      break;
+    }
+
+    case Dali::DevelActor::Property::SIBLING_ORDER:
+    {
+      value = static_cast<int>( GetSiblingOrder() );
+      break;
+    }
+
+    case Dali::DevelActor::Property::SCREEN_POSITION:
+    {
+      value = GetCurrentScreenPosition();
+      break;
+    }
+
+    case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+    {
+      value = mPositionUsesAnchorPoint;
+      break;
+    }
+
+    case Dali::Actor::Property::LAYOUT_DIRECTION:
+    {
+      value = mLayoutDirection;
+      break;
+    }
+
+    case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+    {
+      value = IsLayoutDirectionInherited();
+      break;
+    }
+
+    default:
+    {
+      // Must be a scene-graph only property
+      valueSet = false;
+      break;
+    }
+  }
+
+  return valueSet;
+}
+
+bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& value  ) const
+{
+  bool valueSet = true;
+
+  switch( index )
+  {
+    case Dali::Actor::Property::SIZE:
+    {
+      value = GetCurrentSize();
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_WIDTH:
+    {
+      value = GetCurrentSize().width;
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_HEIGHT:
+    {
+      value = GetCurrentSize().height;
+      break;
+    }
+
+    case Dali::Actor::Property::SIZE_DEPTH:
+    {
+      value = GetCurrentSize().depth;
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION:
+    {
+      value = GetCurrentPosition();
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_X:
+    {
+      value = GetCurrentPosition().x;
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_Y:
+    {
+      value = GetCurrentPosition().y;
+      break;
+    }
+
+    case Dali::Actor::Property::POSITION_Z:
+    {
+      value = GetCurrentPosition().z;
+      break;
+    }
+
+    case Dali::Actor::Property::WORLD_POSITION:
+    {
+      value = GetCurrentWorldPosition();
+      break;
+    }
+
+    case Dali::Actor::Property::WORLD_POSITION_X:
+    {
+      value = GetCurrentWorldPosition().x;
+      break;
+    }
+
+    case Dali::Actor::Property::WORLD_POSITION_Y:
+    {
+      value = GetCurrentWorldPosition().y;
+      break;
+    }
+
+    case Dali::Actor::Property::WORLD_POSITION_Z:
+    {
+      value = GetCurrentWorldPosition().z;
+      break;
+    }
+
+    case Dali::Actor::Property::ORIENTATION:
+    {
+      value = GetCurrentOrientation();
+      break;
+    }
+
+    case Dali::Actor::Property::WORLD_ORIENTATION:
+    {
+      value = GetCurrentWorldOrientation();
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE:
+    {
+      value = GetCurrentScale();
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE_X:
+    {
+      value = GetCurrentScale().x;
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE_Y:
+    {
+      value = GetCurrentScale().y;
+      break;
+    }
+
+    case Dali::Actor::Property::SCALE_Z:
+    {
+      value = GetCurrentScale().z;
+      break;
+    }
+
+    case Dali::Actor::Property::WORLD_SCALE:
+    {
+      value = GetCurrentWorldScale();
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR:
+    {
+      value = GetCurrentColor();
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_RED:
+    {
+      value = GetCurrentColor().r;
+      break;
+    }
+
+    case Dali::Actor::Property::COLOR_GREEN:

     {
     {

-      DALI_ASSERT_ALWAYS( mNode != NULL );
+      value = GetCurrentColor().g;
+      break;
+    }

 
 

-      if( NULL != mNode )
-      {
-        // Disconnect the Node & its children from the scene-graph.
-        DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
-      }
+    case Dali::Actor::Property::COLOR_BLUE:
+    {
+      value = GetCurrentColor().b;
+      break;
+    }

 
 

-      // Instruct each actor to discard pointers to the scene-graph
-      DisconnectFromStage();
+    case Dali::Actor::Property::COLOR_ALPHA:
+    case Dali::DevelActor::Property::OPACITY:
+    {
+      value = GetCurrentColor().a;
+      break;

     }
     }

-  }
-}

 
 

-SceneGraph::Node* Actor::CreateNode() const
-{
-  return Node::New();
-}
+    case Dali::Actor::Property::WORLD_COLOR:
+    {
+      value = GetCurrentWorldColor();
+      break;
+    }

 
 

-bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
-{
-  bool done = false;
-  Actor* actor = dynamic_cast< Actor* >( object );
+    case Dali::Actor::Property::WORLD_MATRIX:
+    {
+      value = GetCurrentWorldMatrix();
+      break;
+    }

 
 

-  if( actor )
-  {
-    if( 0 == actionName.compare( ACTION_SHOW ) )
+    case Dali::Actor::Property::VISIBLE:

     {
     {

-      actor->SetVisible( true );
-      done = true;
+      value = IsVisible();
+      break;

     }
     }

-    else if( 0 == actionName.compare( ACTION_HIDE ) )
+
+    default:

     {
     {

-      actor->SetVisible( false );
-      done = true;
+      // Must be an event-side only property
+      valueSet = false;
+      break;

     }
   }
 
     }
   }
 

-  return done;
+  return valueSet;

 }
 
 void Actor::EnsureRelayoutData()
 }
 
 void Actor::EnsureRelayoutData()


@@ -3717,7 +4633,7 @@ float Actor::NegotiateFromChildren( Dimension::Type dimension )
 
 float Actor::GetSize( Dimension::Type dimension ) const
 {
 
 float Actor::GetSize( Dimension::Type dimension ) const
 {

-  return GetDimensionValue( GetTargetSize(), dimension );
+  return GetDimensionValue( mTargetSize, dimension );

 }
 
 float Actor::GetNaturalSize( Dimension::Type dimension ) const
 }
 
 float Actor::GetNaturalSize( Dimension::Type dimension ) const


@@ -3883,7 +4799,7 @@ void Actor::NegotiateDimensions( const Vector2& allocatedSize )
   }
 }
 
   }
 }
 

-Vector2 Actor::ApplySizeSetPolicy( const Vector2 size )
+Vector2 Actor::ApplySizeSetPolicy( const Vector2& size )

 {
   switch( mRelayoutData->sizeSetPolicy )
   {
 {
   switch( mRelayoutData->sizeSetPolicy )
   {


@@ -3940,6 +4856,7 @@ Vector2 Actor::ApplySizeSetPolicy( const Vector2 size )
           return size;
         }
       }
           return size;
         }
       }

+      break;

     }
 
     default:
     }
 
     default:


@@ -3979,6 +4896,24 @@ void Actor::SetNegotiatedSize( RelayoutContainer& container )
 
 void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& container )
 {
 
 void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& container )
 {

+  // Force a size negotiation for actors that has assigned size during relayout
+  // This is required as otherwise the flags that force a relayout will not
+  // necessarilly be set. This will occur if the actor has already been laid out.
+  // The dirty flags are then cleared. Then if the actor is added back into the
+  // relayout container afterwards, the dirty flags would still be clear...
+  // causing a relayout to be skipped. Here we force any actors added to the
+  // container to be relayed out.
+  DALI_LOG_TIMER_START( NegSizeTimer1 );
+
+  if( GetUseAssignedSize(Dimension::WIDTH ) )
+  {
+    SetLayoutNegotiated( false, Dimension::WIDTH );
+  }
+  if( GetUseAssignedSize( Dimension::HEIGHT ) )
+  {
+    SetLayoutNegotiated( false, Dimension::HEIGHT );
+  }
+

   // Do the negotiation
   NegotiateDimensions( allocatedSize );
 
   // Do the negotiation
   NegotiateDimensions( allocatedSize );
 


@@ -3986,18 +4921,62 @@ void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& cont
   SetNegotiatedSize( container );
 
   // Negotiate down to children
   SetNegotiatedSize( container );
 
   // Negotiate down to children

-  const Vector2 newBounds = GetTargetSize().GetVectorXY();
-

   for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
   {
     ActorPtr child = GetChildAt( i );
 
   for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
   {
     ActorPtr child = GetChildAt( i );
 

+    // Forces children that have already been laid out to be relayed out
+    // if they have assigned size during relayout.
+    if( child->GetUseAssignedSize(Dimension::WIDTH) )
+    {
+      child->SetLayoutNegotiated(false, Dimension::WIDTH);
+      child->SetLayoutDirty(true, Dimension::WIDTH);
+    }
+
+    if( child->GetUseAssignedSize(Dimension::HEIGHT) )
+    {
+      child->SetLayoutNegotiated(false, Dimension::HEIGHT);
+      child->SetLayoutDirty(true, Dimension::HEIGHT);
+    }
+

     // Only relayout if required
     if( child->RelayoutRequired() )
     {
     // Only relayout if required
     if( child->RelayoutRequired() )
     {

-      container.Add( Dali::Actor( child.Get() ), newBounds );
+      container.Add( Dali::Actor( child.Get() ), mTargetSize.GetVectorXY() );
+    }
+  }
+  DALI_LOG_TIMER_END( NegSizeTimer1, gLogRelayoutFilter, Debug::Concise, "NegotiateSize() took: ");
+}
+
+void Actor::SetUseAssignedSize( bool use, Dimension::Type dimension )
+{
+  if( mRelayoutData )
+  {
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+    {
+      if( dimension & ( 1 << i ) )
+      {
+        mRelayoutData->useAssignedSize[ i ] = use;
+      }
+    }
+  }
+}
+
+bool Actor::GetUseAssignedSize( Dimension::Type dimension ) const
+{
+  if ( mRelayoutData )
+  {
+    // If more than one dimension is requested, just return the first one found
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+    {
+      if( dimension & ( 1 << i ) )
+      {
+        return mRelayoutData->useAssignedSize[ i ];
+      }

     }
   }
     }
   }

+
+  return false;

 }
 
 void Actor::RelayoutRequest( Dimension::Type dimension )
 }
 
 void Actor::RelayoutRequest( Dimension::Type dimension )


@@ -4041,7 +5020,7 @@ Vector2 Actor::GetPreferredSize() const
 {
   if ( mRelayoutData )
   {
 {
   if ( mRelayoutData )
   {

-    return mRelayoutData->preferredSize;
+    return Vector2( mRelayoutData->preferredSize );

   }
 
   return GetDefaultPreferredSize();
   }
 
   return GetDefaultPreferredSize();


@@ -4109,6 +5088,287 @@ float Actor::GetMaximumSize( Dimension::Type dimension ) const
   return FLT_MAX;  // Default
 }
 
   return FLT_MAX;  // Default
 }
 

+Object* Actor::GetParentObject() const
+{
+  return mParent;
+}
+
+void Actor::SetVisibleInternal( bool visible, SendMessage::Type sendMessage )
+{
+  if( mVisible != visible )
+  {
+    if( sendMessage == SendMessage::TRUE && NULL != mNode )
+    {
+      // mNode is being used in a separate thread; queue a message to set the value & base value
+      SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, &mNode->mVisible, &AnimatableProperty<bool>::Bake, visible );
+    }
+
+    mVisible = visible;
+
+    // Emit the signal on this actor and all its children
+    EmitVisibilityChangedSignalRecursively( this, visible, DevelActor::VisibilityChange::SELF );
+  }
+}
+
+void Actor::SetSiblingOrder( unsigned int order )
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    unsigned int currentOrder = GetSiblingOrder();
+
+    if( order != currentOrder )
+    {
+      if( order == 0 )
+      {
+        LowerToBottom();
+      }
+      else if( order < siblings.size() -1 )
+      {
+        if( order > currentOrder )
+        {
+          RaiseAbove( *siblings[order] );
+        }
+        else
+        {
+          LowerBelow( *siblings[order] );
+        }
+      }
+      else
+      {
+        RaiseToTop();
+      }
+    }
+  }
+}
+
+unsigned int Actor::GetSiblingOrder() const
+{
+  unsigned int order = 0;
+
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    for( size_t i=0; i<siblings.size(); ++i )
+    {
+      if( siblings[i] == this )
+      {
+        order = i;
+        break;
+      }
+    }
+  }
+
+  return order;
+}
+
+void Actor::RequestRebuildDepthTree()
+{
+  if( mIsOnStage )
+  {
+    StagePtr stage = Stage::GetCurrent();
+    if( stage )
+    {
+      stage->RequestRebuildDepthTree();
+    }
+  }
+}
+
+void Actor::Raise()
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    if( siblings.back() != this ) // If not already at end
+    {
+      for( size_t i=0; i<siblings.size(); ++i )
+      {
+        if( siblings[i] == this )
+        {
+          // Swap with next
+          ActorPtr next = siblings[i+1];
+          siblings[i+1] = this;
+          siblings[i] = next;
+          break;
+        }
+      }
+    }
+    RequestRebuildDepthTree();
+  }
+  else
+  {
+    DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+  }
+}
+
+void Actor::Lower()
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    if( siblings.front() != this ) // If not already at beginning
+    {
+      for( size_t i=1; i<siblings.size(); ++i )
+      {
+        if( siblings[i] == this )
+        {
+          // Swap with previous
+          ActorPtr previous = siblings[i-1];
+          siblings[i-1] = this;
+          siblings[i] = previous;
+          break;
+        }
+      }
+    }
+    RequestRebuildDepthTree();
+  }
+  else
+  {
+    DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+  }
+}
+
+void Actor::RaiseToTop()
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    if( siblings.back() != this ) // If not already at end
+    {
+      ActorContainer::iterator iter = std::find( siblings.begin(), siblings.end(), this );
+      if( iter != siblings.end() )
+      {
+        siblings.erase(iter);
+        siblings.push_back(ActorPtr(this));
+      }
+    }
+    RequestRebuildDepthTree();
+  }
+  else
+  {
+    DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+  }
+}
+
+void Actor::LowerToBottom()
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    if( siblings.front() != this ) // If not already at bottom,
+    {
+      ActorPtr thisPtr(this); // ensure this actor remains referenced.
+
+      ActorContainer::iterator iter = std::find( siblings.begin(), siblings.end(), this );
+      if( iter != siblings.end() )
+      {
+        siblings.erase(iter);
+        siblings.insert(siblings.begin(), thisPtr);
+      }
+    }
+    RequestRebuildDepthTree();
+  }
+  else
+  {
+    DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+  }
+}
+
+void Actor::RaiseAbove( Internal::Actor& target )
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    if( siblings.back() != this && target.mParent == mParent ) // If not already at top
+    {
+      ActorPtr thisPtr(this); // ensure this actor remains referenced.
+
+      ActorContainer::iterator targetIter = std::find( siblings.begin(), siblings.end(), &target );
+      ActorContainer::iterator thisIter = std::find( siblings.begin(), siblings.end(), this );
+      if( thisIter < targetIter )
+      {
+        siblings.erase(thisIter);
+        // Erasing early invalidates the targetIter. (Conversely, inserting first may also
+        // invalidate thisIter)
+        targetIter = std::find( siblings.begin(), siblings.end(), &target );
+        ++targetIter;
+        siblings.insert(targetIter, thisPtr);
+      }
+      RequestRebuildDepthTree();
+    }
+  }
+  else
+  {
+    DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+  }
+}
+
+void Actor::LowerBelow( Internal::Actor& target )
+{
+  if ( mParent )
+  {
+    ActorContainer& siblings = *(mParent->mChildren);
+    if( siblings.front() != this && target.mParent == mParent ) // If not already at bottom
+    {
+      ActorPtr thisPtr(this); // ensure this actor remains referenced.
+
+      ActorContainer::iterator targetIter = std::find( siblings.begin(), siblings.end(), &target );
+      ActorContainer::iterator thisIter = std::find( siblings.begin(), siblings.end(), this );
+
+      if( thisIter > targetIter )
+      {
+        siblings.erase(thisIter); // this only invalidates iterators at or after this point.
+        siblings.insert(targetIter, thisPtr);
+      }
+      RequestRebuildDepthTree();
+    }
+  }
+  else
+  {
+    DALI_LOG_WARNING( "Actor must have a parent, Sibling order not changed.\n" );
+  }
+}
+
+void Actor::SetInheritLayoutDirection( bool inherit )
+{
+  if( mInheritLayoutDirection != inherit )
+  {
+    mInheritLayoutDirection = inherit;
+
+    if( inherit && mParent )
+    {
+      InheritLayoutDirectionRecursively( this, mParent->mLayoutDirection );
+    }
+  }
+}
+
+bool Actor::IsLayoutDirectionInherited() const
+{
+  return mInheritLayoutDirection;
+}
+
+void Actor::InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set )
+{
+  if( actor && ( actor->mInheritLayoutDirection || set ) )
+  {
+    if( actor->mLayoutDirection != direction)
+    {
+      actor->mLayoutDirection = direction;
+      actor->EmitLayoutDirectionChangedSignal( direction );
+      actor->RelayoutRequest();
+    }
+
+    if( actor->GetChildCount() > 0 )
+    {
+      ActorContainer& children = actor->GetChildrenInternal();
+      for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+      {
+        InheritLayoutDirectionRecursively( *iter, direction );
+      }
+    }
+  }
+}
+

 } // namespace Internal
 
 } // namespace Dali
 } // namespace Internal
 
 } // namespace Dali