Added RenderTask WorldToViewport coordinates
[platform/core/uifw/dali-core.git] / dali / internal / event / actors / actor-impl.cpp
index 64d3845..614c6e4 100644 (file)
 #include <dali/internal/common/message.h>
 #include <dali/integration-api/debug.h>
 
-#ifdef DALI_DYNAMICS_SUPPORT
-#include <dali/internal/event/dynamics/dynamics-body-config-impl.h>
-#include <dali/internal/event/dynamics/dynamics-body-impl.h>
-#include <dali/internal/event/dynamics/dynamics-joint-impl.h>
-#include <dali/internal/event/dynamics/dynamics-world-impl.h>
-#endif
-
 using Dali::Internal::SceneGraph::Node;
 using Dali::Internal::SceneGraph::AnimatableProperty;
 using Dali::Internal::SceneGraph::PropertyBase;
@@ -103,13 +96,37 @@ namespace Internal
 
 unsigned int Actor::mActorCounter = 0;
 
+namespace
+{
+/// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
+inline const Vector3& GetDefaultSizeModeFactor()
+{
+  return Vector3::ONE;
+}
+
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultPreferredSize()
+{
+  return Vector2::ZERO;
+}
+
+/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
+inline const Vector2& GetDefaultDimensionPadding()
+{
+  return Vector2::ZERO;
+}
+
+const SizeScalePolicy::Type DEFAULT_SIZE_SCALE_POLICY = SizeScalePolicy::USE_SIZE_SET;
+
+} // unnamed namespace
+
 /**
  * Struct to collect relayout variables
  */
 struct Actor::RelayoutData
 {
   RelayoutData()
-    : sizeModeFactor( Vector3::ONE ), preferredSize( Vector2::ZERO ), sizeSetPolicy( SizeScalePolicy::USE_SIZE_SET ), relayoutEnabled( false ), insideRelayout( false )
+    : sizeModeFactor( GetDefaultSizeModeFactor() ), preferredSize( GetDefaultPreferredSize() ), sizeSetPolicy( DEFAULT_SIZE_SCALE_POLICY ), relayoutEnabled( false ), insideRelayout( false )
   {
     // Set size negotiation defaults
     for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
@@ -119,7 +136,7 @@ struct Actor::RelayoutData
       dimensionNegotiated[ i ] = false;
       dimensionDirty[ i ] = false;
       dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
-      dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
+      dimensionPadding[ i ] = GetDefaultDimensionPadding();
       minimumSize[ i ] = 0.0f;
       maximumSize[ i ] = FLT_MAX;
     }
@@ -149,28 +166,6 @@ struct Actor::RelayoutData
   bool insideRelayout :1;                    ///< Locking flag to prevent recursive relayouts on size set
 };
 
-#ifdef DALI_DYNAMICS_SUPPORT
-
-// Encapsulate actor related dynamics data
-struct DynamicsData
-{
-  DynamicsData( Actor* slotOwner )
-  : slotDelegate( slotOwner )
-  {
-  }
-
-  typedef std::map<Actor*, DynamicsJointPtr> JointContainer;
-  typedef std::vector<DynamicsJointPtr> ReferencedJointContainer;
-
-  DynamicsBodyPtr body;
-  JointContainer joints;
-  ReferencedJointContainer referencedJoints;
-
-  SlotDelegate< Actor > slotDelegate;
-};
-
-#endif // DALI_DYNAMICS_SUPPORT
-
 namespace // unnamed namespace
 {
 
@@ -182,67 +177,67 @@ namespace // unnamed namespace
  *              Name                Type   writable animatable constraint-input  enum for index-checking
  */
 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( "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( "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( "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( "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( "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( "world-orientation", ROTATION, false, false, true,  Dali::Actor::Property::WORLD_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( "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( "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( "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( "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( "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( "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( "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( "minimumSize",       VECTOR2,  true,  false, false, Dali::Actor::Property::MINIMUM_SIZE )
+DALI_PROPERTY( "maximumSize",       VECTOR2,  true,  false, false, Dali::Actor::Property::MAXIMUM_SIZE )
 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";
 
 // Actions
 
@@ -412,7 +407,7 @@ void Actor::Add( Actor& child )
     if( !child.mParent )
     {
       // Do this first, since user callbacks from within SetParent() may need to remove child
-      mChildren->push_back( Dali::Actor( &child ) );
+      mChildren->push_back( ActorPtr( &child ) );
 
       // SetParent asserts that child can be added
       child.SetParent( this );
@@ -429,91 +424,32 @@ void Actor::Add( Actor& child )
   }
 }
 
-void Actor::Insert( unsigned int index, Actor& child )
-{
-  DALI_ASSERT_ALWAYS( this != &child && "Cannot add actor to itself" );
-  DALI_ASSERT_ALWAYS( !child.IsRoot() && "Cannot add root actor" );
-
-  if( !mChildren )
-  {
-    mChildren = new ActorContainer;
-  }
-
-  Actor* const oldParent( child.mParent );
-
-  // since an explicit position has been given, always insert, even if already a child
-  if( oldParent )
-  {
-    oldParent->Remove( child ); // This causes OnChildRemove callback
-
-    // Old parent may need to readjust to missing child
-    if( oldParent->RelayoutDependentOnChildren() )
-    {
-      oldParent->RelayoutRequest();
-    }
-  }
-
-  // Guard against Add() during previous OnChildRemove callback
-  if( !child.mParent )
-  {
-    // Do this first, since user callbacks from within SetParent() may need to remove child
-    if( index < GetChildCount() )
-    {
-      ActorIter it = mChildren->begin();
-      std::advance( it, index );
-      mChildren->insert( it, Dali::Actor( &child ) );
-    }
-    else
-    {
-      mChildren->push_back( Dali::Actor( &child ) );
-    }
-    // SetParent asserts that child can be added
-    child.SetParent( this, index );
-
-    // Notification for derived classes
-    OnChildAdd( child );
-
-    // Only put in a relayout request if there is a suitable dependency
-    if( RelayoutDependentOnChildren() )
-    {
-      RelayoutRequest();
-    }
-
-    if( child.RelayoutDependentOnParent() )
-    {
-      child.RelayoutRequest();
-    }
-  }
-}
-
 void Actor::Remove( Actor& child )
 {
-  DALI_ASSERT_ALWAYS( this != &child && "Cannot remove actor from itself" );
-
-  Dali::Actor removed;
-
-  if( !mChildren )
+  if( (this == &child) || (!mChildren) )
   {
-    // no children
+    // no children or removing itself
     return;
   }
 
+  ActorPtr removed;
+
   // Find the child in mChildren, and unparent it
   ActorIter end = mChildren->end();
   for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
   {
-    Actor& actor = GetImplementation( *iter );
+    ActorPtr actor = (*iter);
 
-    if( &actor == &child )
+    if( actor.Get() == &child )
     {
       // Keep handle for OnChildRemove notification
-      removed = Dali::Actor( &actor );
+      removed = actor;
 
       // Do this first, since user callbacks from within SetParent() may need to add the child
       mChildren->erase( iter );
 
-      DALI_ASSERT_DEBUG( actor.GetParent() == this );
-      actor.SetParent( NULL );
+      DALI_ASSERT_DEBUG( actor->GetParent() == this );
+      actor->SetParent( NULL );
 
       break;
     }
@@ -522,7 +458,7 @@ void Actor::Remove( Actor& child )
   if( removed )
   {
     // Notification for derived classes
-    OnChildRemove( GetImplementation( removed ) );
+    OnChildRemove( *(removed.Get()) );
 
     // Only put in a relayout request if there is a suitable dependency
     if( RelayoutDependentOnChildren() )
@@ -548,11 +484,11 @@ unsigned int Actor::GetChildCount() const
   return ( NULL != mChildren ) ? mChildren->size() : 0;
 }
 
-Dali::Actor Actor::GetChildAt( unsigned int index ) const
+ActorPtr Actor::GetChildAt( unsigned int index ) const
 {
   DALI_ASSERT_ALWAYS( index < GetChildCount() );
 
-  return ( ( mChildren ) ? ( *mChildren )[ index ] : Dali::Actor() );
+  return ( ( mChildren ) ? ( *mChildren )[ index ] : ActorPtr() );
 }
 
 ActorPtr Actor::FindChildByName( const std::string& actorName )
@@ -567,7 +503,7 @@ ActorPtr Actor::FindChildByName( const std::string& actorName )
     ActorIter end = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
     {
-      child = GetImplementation( *iter ).FindChildByName( actorName );
+      child = (*iter)->FindChildByName( actorName );
 
       if( child )
       {
@@ -590,7 +526,7 @@ ActorPtr Actor::FindChildById( const unsigned int id )
     ActorIter end = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
     {
-      child = GetImplementation( *iter ).FindChildById( id );
+      child = (*iter)->FindChildById( id );
 
       if( child )
       {
@@ -917,36 +853,7 @@ void Actor::SetScaleZ( float z )
   }
 }
 
-void Actor::SetInitialVolume( const Vector3& volume )
-{
-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value
-    SetInitialVolumeMessage( GetEventThreadServices(), *mNode, volume );
-  }
-}
-
-void Actor::SetTransmitGeometryScaling( bool transmitGeometryScaling )
-{
-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value
-    SetTransmitGeometryScalingMessage( GetEventThreadServices(), *mNode, transmitGeometryScaling );
-  }
-}
-
-bool Actor::GetTransmitGeometryScaling() const
-{
-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetTransmitGeometryScaling();
-  }
-
-  return false;
-}
-
-void Actor::ScaleBy( const Vector3& relativeScale )
+void Actor::ScaleBy(const Vector3& relativeScale)
 {
   if( NULL != mNode )
   {
@@ -1132,9 +1039,12 @@ void Actor::SetSizeModeFactor( const Vector3& factor )
 
 const Vector3& Actor::GetSizeModeFactor() const
 {
-  EnsureRelayoutData();
+  if ( mRelayoutData )
+  {
+    return mRelayoutData->sizeModeFactor;
+  }
 
-  return mRelayoutData->sizeModeFactor;
+  return GetDefaultSizeModeFactor();
 }
 
 void Actor::SetColorMode( ColorMode colorMode )
@@ -1166,23 +1076,19 @@ void Actor::SetSize( float width, float height, float depth )
 
 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 )
 {
-  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 )
   {
+    // TODO we cannot just ignore the given Z but that means rewrite the size negotiation!!
     SetPreferredSize( size.GetVectorXY() );
   }
   else
@@ -1326,14 +1232,15 @@ void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimensio
 
 ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  // If more than one dimension is requested, just return the first one found
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( ( dimension & ( 1 << i ) ) )
+    // If more than one dimension is requested, just return the first one found
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return mRelayoutData->resizePolicies[ i ];
+      if( ( dimension & ( 1 << i ) ) )
+      {
+        return mRelayoutData->resizePolicies[ i ];
+      }
     }
   }
 
@@ -1349,9 +1256,12 @@ void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
 
 SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
 {
-  EnsureRelayoutData();
+  if ( mRelayoutData )
+  {
+    return mRelayoutData->sizeSetPolicy;
+  }
 
-  return mRelayoutData->sizeSetPolicy;
+  return DEFAULT_SIZE_SCALE_POLICY;
 }
 
 void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
@@ -1369,14 +1279,15 @@ void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type d
 
 Dimension::Type Actor::GetDimensionDependency( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  // If more than one dimension is requested, just return the first one found
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( ( dimension & ( 1 << i ) ) )
+    // If more than one dimension is requested, just return the first one found
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return mRelayoutData->dimensionDependencies[ i ];
+      if( ( dimension & ( 1 << i ) ) )
+      {
+        return mRelayoutData->dimensionDependencies[ i ];
+      }
     }
   }
 
@@ -1417,13 +1328,14 @@ void Actor::SetLayoutDirty( bool dirty, Dimension::Type dimension )
 
 bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return true;
+      if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
+      {
+        return true;
+      }
     }
   }
 
@@ -1432,408 +1344,95 @@ bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
 
 bool Actor::RelayoutPossible( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
+  return mRelayoutData && mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
 }
 
 bool Actor::RelayoutRequired( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  return mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
-}
-
-#ifdef DALI_DYNAMICS_SUPPORT
-
-//--------------- Dynamics ---------------
-
-void Actor::DisableDynamics()
-{
-  if( NULL != mDynamicsData )
-  {
-    DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str());
-
-    // ensure dynamics object are disconnected from scene
-    DisconnectDynamics();
-
-    // delete joint owned by this actor
-    while( !mDynamicsData->joints.empty() )
-    {
-      RemoveDynamicsJoint( mDynamicsData->joints.begin()->second );
-    }
-
-    // delete other joints referencing this actor
-    while( !mDynamicsData->referencedJoints.empty() )
-    {
-      DynamicsJointPtr joint( *(mDynamicsData->referencedJoints.begin()) );
-      ActorPtr jointOwner( joint->GetActor( true ) );
-      if( jointOwner )
-      {
-        jointOwner->RemoveDynamicsJoint( joint );
-      }
-      else
-      {
-        mDynamicsData->referencedJoints.erase( mDynamicsData->referencedJoints.begin() );
-      }
-    }
-    // delete the DynamicsBody object
-    mDynamicsData->body.Reset();
-
-    // Discard Dynamics data structure
-    delete mDynamicsData;
-    mDynamicsData = NULL;
-  }
-}
-
-DynamicsBodyPtr Actor::GetDynamicsBody() const
-{
-  DynamicsBodyPtr body;
-
-  if( NULL != mDynamicsData )
-  {
-    body = mDynamicsData->body;
-  }
-
-  return body;
+  return mRelayoutData && mRelayoutData->relayoutEnabled && IsLayoutDirty( dimension );
 }
 
-DynamicsBodyPtr Actor::EnableDynamics(DynamicsBodyConfigPtr bodyConfig)
+unsigned int Actor::AddRenderer( Renderer& renderer )
 {
-  DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s- (\"%s\")\n", __PRETTY_FUNCTION__, mName.c_str());
-
-  if( NULL == mDynamicsData )
+  if( !mRenderers )
   {
-    mDynamicsData = new DynamicsData( this );
+    mRenderers = new RendererContainer;
   }
 
-  if( !mDynamicsData->body )
-  {
-    mDynamicsData->body = new DynamicsBody(mName, bodyConfig, *this, *(const_cast<SceneGraph::Node*>(mNode)) );
-
-    if( OnStage() )
-    {
-      DynamicsWorldPtr world( DynamicsWorld::Get() );
-      if( world )
-      {
-        if( mParent == world->GetRootActor().Get() )
-        {
-          mDynamicsData->body->Connect( GetEventThreadServices() );
-        }
-      }
-    }
-  }
-
-  return mDynamicsData->body;
-}
-
-DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offset )
-{
-  DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" );
-  return AddDynamicsJoint( attachedActor, offset, ( GetCurrentPosition() + offset ) - attachedActor->GetCurrentPosition() );
-}
-
-DynamicsJointPtr Actor::AddDynamicsJoint( ActorPtr attachedActor, const Vector3& offsetA, const Vector3& offsetB )
-{
-  DALI_ASSERT_ALWAYS( attachedActor && "'attachedActor' must be initialized!" );
-  DALI_ASSERT_ALWAYS( this != attachedActor.Get() && "Cannot create a joint to oneself!" );
+  unsigned int index = mRenderers->size();
+  RendererPtr rendererPtr = RendererPtr( &renderer );
+  mRenderers->push_back( rendererPtr );
+  AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
 
-  DynamicsJointPtr joint;
-
-  DynamicsWorldPtr world( DynamicsWorld::Get() );
-
-  if( world )
+  if( mIsOnStage)
   {
-    if( NULL != mDynamicsData )
-    {
-      DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-
-      if( mDynamicsData->joints.end() != it )
-      {
-        // use existing joint
-        joint = it->second;
-      }
-
-      if( !joint )
-      {
-        DynamicsBodyPtr bodyA( GetDynamicsBody() );
-        DynamicsBodyPtr bodyB( attachedActor->GetDynamicsBody() );
-
-        if( !bodyA )
-        {
-          bodyA = EnableDynamics( new DynamicsBodyConfig );
-        }
-
-        if( !bodyB )
-        {
-          bodyB = attachedActor->EnableDynamics( new DynamicsBodyConfig );
-        }
-
-        joint = new DynamicsJoint(world, bodyA, bodyB, offsetA, offsetB);
-        mDynamicsData->joints[ attachedActor.Get() ] = joint;
-
-        if( OnStage() && attachedActor->OnStage() )
-        {
-          joint->Connect( GetEventThreadServices() );
-        }
-
-        attachedActor->ReferenceJoint( joint );
-
-        attachedActor->OnStageSignal().Connect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage );
-        attachedActor->OffStageSignal().Connect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage );
-      }
-    }
+    rendererPtr->Connect();
   }
-  return joint;
-}
 
-const int Actor::GetNumberOfJoints() const
-{
-  return static_cast<int>( NULL != mDynamicsData ? mDynamicsData->joints.size() : 0 );
+  return index;
 }
 
-DynamicsJointPtr Actor::GetDynamicsJointByIndex( const int index ) const
+unsigned int Actor::GetRendererCount() const
 {
-  DynamicsJointPtr joint;
-
-  if( NULL != mDynamicsData )
+  unsigned int rendererCount(0);
+  if( mRenderers )
   {
-    if( index >= 0 && index < static_cast<int>(mDynamicsData->joints.size()) )
-    {
-      DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.begin() );
-
-      for( int i = 0; i < index; ++i )
-      {
-        ++it;
-      }
-
-      joint = it->second;
-    }
+    rendererCount = mRenderers->size();
   }
 
-  return joint;
+  return rendererCount;
 }
 
-DynamicsJointPtr Actor::GetDynamicsJoint( ActorPtr attachedActor ) const
+RendererPtr Actor::GetRendererAt( unsigned int index )
 {
-  DynamicsJointPtr joint;
-
-  if( NULL != mDynamicsData )
+  RendererPtr renderer;
+  if( index < GetRendererCount() )
   {
-    DynamicsData::JointContainer::const_iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-
-    if( mDynamicsData->joints.end() != it )
-    {
-      // use existing joint
-      joint = it->second;
-    }
+    renderer = ( *mRenderers )[ index ];
   }
 
-  return joint;
+  return renderer;
 }
 
-void Actor::RemoveDynamicsJoint( DynamicsJointPtr joint )
+void Actor::RemoveRenderer( Renderer& renderer )
 {
-  if( NULL != mDynamicsData )
+  if( mRenderers )
   {
-    DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
-    DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
-    for(; it != endIt; ++it )
+    RendererIter end = mRenderers->end();
+    for( RendererIter iter = mRenderers->begin(); iter != end; ++iter )
     {
-      if( it->second == joint.Get() )
+      if( (*iter).Get() == &renderer )
       {
-        ActorPtr attachedActor( it->first );
-
-        if( OnStage() && attachedActor && attachedActor->OnStage() )
-        {
-          joint->Disconnect( GetEventThreadServices() );
-        }
-
-        if( attachedActor )
-        {
-          attachedActor->ReleaseJoint( joint );
-          attachedActor->OnStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOnStage );
-          attachedActor->OffStageSignal().Disconnect( mDynamicsData->slotDelegate, &Actor::AttachedActorOffStage );
-        }
-
-        mDynamicsData->joints.erase(it);
+        mRenderers->erase( iter );
+        RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
         break;
       }
     }
   }
 }
 
-void Actor::ReferenceJoint( DynamicsJointPtr joint )
-{
-  DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-
-  if( NULL != mDynamicsData )
-  {
-    mDynamicsData->referencedJoints.push_back(joint);
-  }
-}
-
-void Actor::ReleaseJoint( DynamicsJointPtr joint )
-{
-  DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-
-  if( NULL != mDynamicsData )
-  {
-    DynamicsData::ReferencedJointContainer::iterator it( std::find( mDynamicsData->referencedJoints.begin(), mDynamicsData->referencedJoints.end(), joint ) );
-
-    if( it != mDynamicsData->referencedJoints.end() )
-    {
-      mDynamicsData->referencedJoints.erase( it );
-    }
-  }
-}
-
-void Actor::SetDynamicsRoot(bool flag)
-{
-  if( mIsDynamicsRoot != flag )
-  {
-    mIsDynamicsRoot = flag;
-
-    if( OnStage() && mChildren )
-    {
-      // walk the children connecting or disconnecting any dynamics enabled child from the dynamics simulation
-      ActorIter end = mChildren->end();
-      for( ActorIter iter = mChildren->begin(); iter != end; ++iter )
-      {
-        Actor& child = GetImplementation(*iter);
-
-        if( child.GetDynamicsBody() )
-        {
-          if( mIsDynamicsRoot )
-          {
-            child.ConnectDynamics();
-          }
-          else
-          {
-            child.DisconnectDynamics();
-          }
-        }
-      }
-    }
-  }
-}
-
-bool Actor::IsDynamicsRoot() const
-{
-  return mIsDynamicsRoot;
-}
-
-void Actor::AttachedActorOnStage( Dali::Actor actor )
-{
-  DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__);
-
-  if( OnStage() )
-  {
-    ActorPtr attachedActor( &GetImplementation(actor) );
-
-    DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-    if( NULL != mDynamicsData )
-    {
-      DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-      if( mDynamicsData->joints.end() != it )
-      {
-        DynamicsJointPtr joint( it->second );
-        joint->Connect( GetEventThreadServices() );
-      }
-    }
-  }
-}
-
-void Actor::AttachedActorOffStage( Dali::Actor actor )
-{
-  DALI_LOG_INFO(Debug::Filter::gDynamics, Debug::Verbose, "%s\n", __PRETTY_FUNCTION__);
-
-  if( OnStage() )
-  {
-    ActorPtr attachedActor( &GetImplementation(actor) );
-
-    DALI_ASSERT_DEBUG( NULL != mDynamicsData && "Dynamics not enabled on this actor!" );
-    if( NULL != mDynamicsData )
-    {
-      DynamicsData::JointContainer::iterator it( mDynamicsData->joints.find( attachedActor.Get() ) );
-      if( mDynamicsData->joints.end() != it )
-      {
-        DynamicsJointPtr joint( it->second );
-        joint->Disconnect( GetEventThreadServices() );
-      }
-    }
-  }
-}
-
-void Actor::ConnectDynamics()
-{
-  if( NULL != mDynamicsData && mDynamicsData->body )
-  {
-    if( OnStage() && mParent && mParent->IsDynamicsRoot() )
-    {
-      mDynamicsData->body->Connect( GetEventThreadServices() );
-
-      // Connect all joints where attachedActor is also on stage
-      if( !mDynamicsData->joints.empty() )
-      {
-        DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
-        DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
-        for(; it != endIt; ++it )
-        {
-          Actor* attachedActor( it->first );
-          if( NULL != attachedActor && attachedActor->OnStage() )
-          {
-            DynamicsJointPtr joint( it->second );
-
-            joint->Connect( GetEventThreadServices() );
-          }
-        }
-      }
-    }
-  }
-}
-
-void Actor::DisconnectDynamics()
+void Actor::RemoveRenderer( unsigned int index )
 {
-  if( NULL != mDynamicsData && mDynamicsData->body )
+  if( index < GetRendererCount() )
   {
-    if( OnStage() )
-    {
-      mDynamicsData->body->Disconnect( GetEventThreadServices() );
-
-      // Disconnect all joints
-      if( !mDynamicsData->joints.empty() )
-      {
-        DynamicsData::JointContainer::iterator it( mDynamicsData->joints.begin() );
-        DynamicsData::JointContainer::iterator endIt( mDynamicsData->joints.end() );
-
-        for(; it != endIt; ++it )
-        {
-          DynamicsJointPtr joint( it->second );
-
-          joint->Disconnect( GetEventThreadServices() );
-        }
-      }
-    }
+    RendererPtr renderer = ( *mRenderers )[ index ];
+    RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+    mRenderers->erase( mRenderers->begin()+index );
   }
 }
 
-#endif // DALI_DYNAMICS_SUPPORT
-
 void Actor::SetOverlay( bool enable )
 {
-  // Setting STENCIL will override OVERLAY
+  // Setting STENCIL will override OVERLAY_2D
   if( DrawMode::STENCIL != mDrawMode )
   {
-    SetDrawMode( enable ? DrawMode::OVERLAY : DrawMode::NORMAL );
+    SetDrawMode( enable ? DrawMode::OVERLAY_2D : DrawMode::NORMAL );
   }
 }
 
 bool Actor::IsOverlay() const
 {
-  return ( DrawMode::OVERLAY == mDrawMode );
+  return ( DrawMode::OVERLAY_2D == mDrawMode );
 }
 
 void Actor::SetDrawMode( DrawMode::Type drawMode )
@@ -1877,7 +1476,7 @@ bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float sc
   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
@@ -2054,12 +1653,11 @@ bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vecto
   if( OnStage() &&
   NULL != mNode )
   {
-    BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-
     // Transforms the ray to the local reference system.
-
     // Calculate the inverse of Model matrix
     Matrix invModelMatrix( false/*don't init*/);
+
+    BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
     // 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 ) );
 
@@ -2269,23 +1867,20 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
 Actor::Actor( DerivedType derivedType )
 : mParent( NULL ),
   mChildren( NULL ),
+  mRenderers( NULL ),
   mNode( NULL ),
   mParentOrigin( NULL ),
   mAnchorPoint( NULL ),
   mRelayoutData( NULL ),
-#ifdef DALI_DYNAMICS_SUPPORT
-  mDynamicsData( NULL ),
-#endif
   mGestureData( NULL ),
   mAttachment(),
   mTargetSize( 0.0f, 0.0f, 0.0f ),
   mName(),
   mId( ++mActorCounter ), // actor ID is initialised to start from 1, and 0 is reserved
+  mDepth( 0u ),
   mIsRoot( ROOT_LAYER == derivedType ),
-  mIsRenderable( RENDERABLE == derivedType ),
   mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
   mIsOnStage( false ),
-  mIsDynamicsRoot( false ),
   mSensitive( true ),
   mLeaveRequired( false ),
   mKeyboardFocusable( false ),
@@ -2324,11 +1919,11 @@ Actor::~Actor()
     ActorConstIter endIter = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
     {
-      Actor& actor = GetImplementation( *iter );
-      actor.SetParent( NULL );
+      (*iter)->SetParent( NULL );
     }
   }
   delete mChildren;
+  delete mRenderers;
 
   // Guard to allow handle destruction after Core has been destroyed
   if( EventThreadServices::IsCoreRunning() )
@@ -2342,11 +1937,6 @@ Actor::~Actor()
     GetEventThreadServices().UnregisterObject( this );
   }
 
-#ifdef DALI_DYNAMICS_SUPPORT
-  // Cleanup dynamics
-  delete mDynamicsData;
-#endif
-
   // Cleanup optional gesture data
   delete mGestureData;
 
@@ -2361,39 +1951,39 @@ Actor::~Actor()
   }
 }
 
-void Actor::ConnectToStage( int index )
+void Actor::ConnectToStage( unsigned int parentDepth )
 {
-  // This container is used instead of walking the Actor hierachy.
-  // It protects us when the Actor hierachy is modified during OnStageConnectionExternal callbacks.
+  // This container is used instead of walking the Actor hierarchy.
+  // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
   ActorContainer connectionList;
 
-  // This stage is atomic i.e. not interrupted by user callbacks
-  RecursiveConnectToStage( connectionList, index );
+  // This stage is atomic i.e. not interrupted by user callbacks.
+  RecursiveConnectToStage( connectionList, parentDepth + 1 );
 
   // Notify applications about the newly connected actors.
   const ActorIter endIter = connectionList.end();
   for( ActorIter iter = connectionList.begin(); iter != endIter; ++iter )
   {
-    Actor& actor = GetImplementation( *iter );
-    actor.NotifyStageConnection();
+    (*iter)->NotifyStageConnection();
   }
 
   RelayoutRequest();
 }
 
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index )
+void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth )
 {
   DALI_ASSERT_ALWAYS( !OnStage() );
 
   mIsOnStage = true;
+  mDepth = depth;
 
-  ConnectToSceneGraph( index );
+  ConnectToSceneGraph();
 
   // Notification for internal derived classes
   OnStageConnectionInternal();
 
   // This stage is atomic; avoid emitting callbacks until all Actors are connected
-  connectionList.push_back( Dali::Actor( this ) );
+  connectionList.push_back( ActorPtr( this ) );
 
   // Recursively connect children
   if( mChildren )
@@ -2401,8 +1991,7 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index )
     ActorConstIter endIter = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
     {
-      Actor& actor = GetImplementation( *iter );
-      actor.RecursiveConnectToStage( connectionList );
+      (*iter)->RecursiveConnectToStage( connectionList, depth+1 );
     }
   }
 }
@@ -2411,16 +2000,16 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, int index )
  * This method is called when the Actor is connected to the Stage.
  * The parent must have added its Node to the scene-graph.
  * The child must connect its Node to the parent's Node.
- * This is resursive; the child calls ConnectToStage() for its children.
+ * This is recursive; the child calls ConnectToStage() for its children.
  */
-void Actor::ConnectToSceneGraph( int index )
+void Actor::ConnectToSceneGraph()
 {
   DALI_ASSERT_DEBUG( mNode != NULL); DALI_ASSERT_DEBUG( mParent != NULL); DALI_ASSERT_DEBUG( mParent->mNode != NULL );
 
   if( NULL != mNode )
   {
     // Reparent Node in next Update
-    ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode, index );
+    ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
   }
 
   // Notify attachment
@@ -2429,13 +2018,11 @@ void Actor::ConnectToSceneGraph( int index )
     mAttachment->Connect();
   }
 
-#ifdef DALI_DYNAMICS_SUPPORT
-  // Notify dynamics
-  if( NULL != mDynamicsData )
+  unsigned int rendererCount( GetRendererCount() );
+  for( unsigned int i(0); i<rendererCount; ++i )
   {
-    ConnectDynamics();
+    GetRendererAt(i)->Connect();
   }
-#endif
 
   // Request relayout on all actors that are added to the scenegraph
   RelayoutRequest();
@@ -2451,7 +2038,7 @@ void Actor::NotifyStageConnection()
   if( OnStage() && !mOnStageSignalled )
   {
     // Notification for external (CustomActor) derived classes
-    OnStageConnectionExternal();
+    OnStageConnectionExternal( mDepth );
 
     if( !mOnStageSignal.Empty() )
     {
@@ -2480,8 +2067,7 @@ void Actor::DisconnectFromStage()
   const ActorIter endIter = disconnectionList.end();
   for( ActorIter iter = disconnectionList.begin(); iter != endIter; ++iter )
   {
-    Actor& actor = GetImplementation( *iter );
-    actor.NotifyStageDisconnection();
+    (*iter)->NotifyStageDisconnection();
   }
 }
 
@@ -2495,13 +2081,12 @@ void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
     ActorConstIter endIter = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
     {
-      Actor& actor = GetImplementation( *iter );
-      actor.RecursiveDisconnectFromStage( disconnectionList );
+      (*iter)->RecursiveDisconnectFromStage( disconnectionList );
     }
   }
 
   // This stage is atomic; avoid emitting callbacks until all Actors are disconnected
-  disconnectionList.push_back( Dali::Actor( this ) );
+  disconnectionList.push_back( ActorPtr( this ) );
 
   // Notification for internal derived classes
   OnStageDisconnectionInternal();
@@ -2526,13 +2111,11 @@ void Actor::DisconnectFromSceneGraph()
     mAttachment->Disconnect();
   }
 
-#ifdef DALI_DYNAMICS_SUPPORT
-  // Notify dynamics
-  if( NULL != mDynamicsData )
+  unsigned int rendererCount( GetRendererCount() );
+  for( unsigned int i(0); i<rendererCount; ++i )
   {
-    DisconnectDynamics();
+    GetRendererAt(i)->Disconnect();
   }
-#endif
 }
 
 void Actor::NotifyStageDisconnection()
@@ -2563,10 +2146,9 @@ bool Actor::IsNodeConnected() const
 {
   bool connected( false );
 
-  if( OnStage() &&
-  NULL != mNode )
+  if( OnStage() && ( NULL != mNode ) )
   {
-    if( mNode->IsRoot() || mNode->GetParent() )
+    if( IsRoot() || mNode->GetParent() )
     {
       connected = true;
     }
@@ -2962,7 +2544,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 )
 {
-  switch( entry.type )
+  switch( entry.GetType() )
   {
     case Property::BOOLEAN:
     {
@@ -2986,17 +2568,6 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       break;
     }
 
-    case Property::UNSIGNED_INTEGER:
-    {
-      const AnimatableProperty< unsigned int >* property = dynamic_cast< const AnimatableProperty< unsigned int >* >( entry.GetSceneGraphProperty() );
-      DALI_ASSERT_DEBUG( NULL != property );
-
-      // property is being used in a separate thread; queue a message to set the property
-      SceneGraph::NodePropertyMessage<unsigned int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<unsigned int>::Bake, value.Get<unsigned int>() );
-
-      break;
-    }
-
     case Property::FLOAT:
     {
       const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
@@ -3827,7 +3398,7 @@ int Actor::GetPropertyComponentIndex( Property::Index index ) const
   return componentIndex;
 }
 
-void Actor::SetParent( Actor* parent, int index )
+void Actor::SetParent( Actor* parent )
 {
   if( parent )
   {
@@ -3839,7 +3410,7 @@ void Actor::SetParent( Actor* parent, int index )
          parent->OnStage() )
     {
       // Instruct each actor to create a corresponding node in the scene graph
-      ConnectToStage( index );
+      ConnectToStage( parent->GetHierarchyDepth() );
     }
   }
   else // parent being set to NULL
@@ -3892,7 +3463,7 @@ bool Actor::DoAction( BaseObject* object, const std::string& actionName, const P
   return done;
 }
 
-void Actor::EnsureRelayoutData() const
+void Actor::EnsureRelayoutData()
 {
   // Assign relayout data.
   if( !mRelayoutData )
@@ -4005,22 +3576,25 @@ void Actor::SetPadding( const Vector2& padding, Dimension::Type dimension )
 
 Vector2 Actor::GetPadding( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  // If more than one dimension is requested, just return the first one found
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( ( dimension & ( 1 << i ) ) )
+    // If more than one dimension is requested, just return the first one found
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return mRelayoutData->dimensionPadding[ i ];
+      if( ( dimension & ( 1 << i ) ) )
+      {
+        return mRelayoutData->dimensionPadding[ i ];
+      }
     }
   }
 
-  return Vector2( 0.0f, 0.0f );   // Default
+  return GetDefaultDimensionPadding();
 }
 
 void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
 {
+  EnsureRelayoutData();
+
   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
   {
     if( dimension & ( 1 << i ) )
@@ -4032,11 +3606,14 @@ void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
 
 bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
 {
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return true;
+      if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
+      {
+        return true;
+      }
     }
   }
 
@@ -4153,14 +3730,13 @@ float Actor::NegotiateFromChildren( Dimension::Type dimension )
 
   for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
   {
-    Dali::Actor child = GetChildAt( i );
-    Actor& childImpl = GetImplementation( child );
+    ActorPtr child = GetChildAt( i );
 
-    if( !childImpl.RelayoutDependentOnParent( dimension ) )
+    if( !child->RelayoutDependentOnParent( dimension ) )
     {
       // Calculate the min and max points that the children range across
-      float childPosition = GetDimensionValue( childImpl.GetTargetPosition(), dimension );
-      float dimensionSize = childImpl.GetRelayoutSize( dimension );
+      float childPosition = GetDimensionValue( child->GetTargetPosition(), dimension );
+      float dimensionSize = child->GetRelayoutSize( dimension );
       maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize );
     }
   }
@@ -4289,13 +3865,12 @@ void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& alloca
       {
         for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
         {
-          Dali::Actor child = GetChildAt( i );
-          Actor& childImpl = GetImplementation( child );
+          ActorPtr child = GetChildAt( i );
 
           // Only relayout child first if it is not dependent on this actor
-          if( !childImpl.RelayoutDependentOnParent( dimension ) )
+          if( !child->RelayoutDependentOnParent( dimension ) )
           {
-            childImpl.NegotiateDimension( dimension, allocatedSize, recursionStack );
+            child->NegotiateDimension( dimension, allocatedSize, recursionStack );
           }
         }
       }
@@ -4444,12 +4019,12 @@ void Actor::NegotiateSize( const Vector2& allocatedSize, RelayoutContainer& cont
 
   for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
   {
-    Dali::Actor child = GetChildAt( i );
+    ActorPtr child = GetChildAt( i );
 
     // Only relayout if required
-    if( GetImplementation( child ).RelayoutRequired() )
+    if( child->RelayoutRequired() )
     {
-      container.Add( child, newBounds );
+      container.Add( Dali::Actor( child.Get() ), newBounds );
     }
   }
 }
@@ -4493,9 +4068,12 @@ void Actor::SetPreferredSize( const Vector2& size )
 
 Vector2 Actor::GetPreferredSize() const
 {
-  EnsureRelayoutData();
+  if ( mRelayoutData )
+  {
+    return Vector2( mRelayoutData->preferredSize );
+  }
 
-  return mRelayoutData->preferredSize;
+  return GetDefaultPreferredSize();
 }
 
 void Actor::SetMinimumSize( float size, Dimension::Type dimension )
@@ -4515,13 +4093,14 @@ void Actor::SetMinimumSize( float size, Dimension::Type dimension )
 
 float Actor::GetMinimumSize( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( dimension & ( 1 << i ) )
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return mRelayoutData->minimumSize[ i ];
+      if( dimension & ( 1 << i ) )
+      {
+        return mRelayoutData->minimumSize[ i ];
+      }
     }
   }
 
@@ -4545,17 +4124,18 @@ void Actor::SetMaximumSize( float size, Dimension::Type dimension )
 
 float Actor::GetMaximumSize( Dimension::Type dimension ) const
 {
-  EnsureRelayoutData();
-
-  for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+  if ( mRelayoutData )
   {
-    if( dimension & ( 1 << i ) )
+    for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
     {
-      return mRelayoutData->maximumSize[ i ];
+      if( dimension & ( 1 << i ) )
+      {
+        return mRelayoutData->maximumSize[ i ];
+      }
     }
   }
 
-  return 0.0f;  // Default
+  return FLT_MAX;  // Default
 }
 
 } // namespace Internal