Moved RotationGesture to the Public API

[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 0154209..91f19d9 100644 (file)
--- a/dali/internal/event/actors/actor-impl.cpp
+++ b/dali/internal/event/actors/actor-impl.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.


@@ -27,7 +27,7 @@
 #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/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/events/touch-data.h>
+#include <dali/public-api/events/touch-event.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/math/vector2.h>
 #include <dali/public-api/math/vector3.h>
 #include <dali/public-api/math/radian.h>


@@ -42,6 +42,8 @@
 #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/common/scene-impl.h>
+#include <dali/internal/event/common/thread-local-storage.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>


@@ -68,8 +70,6 @@ namespace Dali
 namespace Internal
 {
 
 namespace Internal
 {
 

-uint32_t Actor::mActorCounter = 0;
-

 namespace
 {
 /// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
 namespace
 {
 /// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.


@@ -193,13 +193,12 @@ DALI_PROPERTY( "sensitive",                 BOOLEAN,  true,  false, false, Dali:
 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( "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( "colorMode",                 INTEGER,  true,  false, false, Dali::Actor::Property::COLOR_MODE )
+DALI_PROPERTY( "drawMode",                  INTEGER,  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( "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( "sizeScalePolicy",           INTEGER,  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( "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 )


@@ -209,20 +208,27 @@ DALI_PROPERTY( "inheritPosition",           BOOLEAN,  true,  false, false, Dali:
 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( "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( "opacity",                   FLOAT,    true,  true,  true,  Dali::Actor::Property::OPACITY )
+DALI_PROPERTY( "screenPosition",            VECTOR2,  false, false, false, Dali::Actor::Property::SCREEN_POSITION )
+DALI_PROPERTY( "positionUsesAnchorPoint",   BOOLEAN,  true,  false, false, Dali::Actor::Property::POSITION_USES_ANCHOR_POINT )
+DALI_PROPERTY( "culled",                    BOOLEAN,  false, false, true,  Dali::Actor::Property::CULLED )
+DALI_PROPERTY( "id",                        INTEGER,  false, false, false, Dali::Actor::Property::ID )
+DALI_PROPERTY( "hierarchyDepth",            INTEGER,  false, false, false, Dali::Actor::Property::HIERARCHY_DEPTH )
+DALI_PROPERTY( "isRoot",                    BOOLEAN,  false, false, false, Dali::Actor::Property::IS_ROOT )
+DALI_PROPERTY( "isLayer",                   BOOLEAN,  false, false, false, Dali::Actor::Property::IS_LAYER )
+DALI_PROPERTY( "connectedToScene",          BOOLEAN,  false, false, false, Dali::Actor::Property::CONNECTED_TO_SCENE )
+DALI_PROPERTY( "keyboardFocusable",         BOOLEAN,  true,  false, false, Dali::Actor::Property::KEYBOARD_FOCUSABLE )

 DALI_PROPERTY( "siblingOrder",              INTEGER,  true,  false, false, Dali::DevelActor::Property::SIBLING_ORDER )
 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( "culled",                    BOOLEAN,  false, false, true, Dali::DevelActor::Property::CULLED )
-DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
+DALI_PROPERTY( "updateSizeHint",            VECTOR2,  true,  false, false, Dali::DevelActor::Property::UPDATE_SIZE_HINT )
+DALI_PROPERTY( "captureAllTouchAfterStart", BOOLEAN,  true,  false, false, Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START )
+DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX, ActorDefaultProperties )

 
 // Signals
 
 
 // Signals
 

-const char* const SIGNAL_TOUCHED = "touched";

 const char* const SIGNAL_HOVERED = "hovered";
 const char* const SIGNAL_WHEEL_EVENT = "wheelEvent";
 const char* const SIGNAL_HOVERED = "hovered";
 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_SCENE = "onScene";
+const char* const SIGNAL_OFF_SCENE = "offScene";

 const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
 const char* const SIGNAL_TOUCH = "touch";
 const char* const SIGNAL_VISIBILITY_CHANGED = "visibilityChanged";
 const char* const SIGNAL_ON_RELAYOUT = "onRelayout";
 const char* const SIGNAL_TOUCH = "touch";
 const char* const SIGNAL_VISIBILITY_CHANGED = "visibilityChanged";


@@ -240,13 +246,12 @@ BaseHandle CreateActor()
   return Dali::Actor::New();
 }
 
   return Dali::Actor::New();
 }
 

-TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor );
+TypeRegistration mType( typeid(Dali::Actor), typeid(Dali::Handle), CreateActor, ActorDefaultProperties );

 
 

-SignalConnectorType signalConnector1( mType, SIGNAL_TOUCHED, &Actor::DoConnectSignal );

 SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector3( mType, SIGNAL_WHEEL_EVENT, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector2( mType, SIGNAL_HOVERED, &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 signalConnector4( mType, SIGNAL_ON_SCENE, &Actor::DoConnectSignal );
+SignalConnectorType signalConnector5( mType, SIGNAL_OFF_SCENE, &Actor::DoConnectSignal );

 SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector8( mType, SIGNAL_VISIBILITY_CHANGED, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector6( mType, SIGNAL_ON_RELAYOUT, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector7( mType, SIGNAL_TOUCH, &Actor::DoConnectSignal );
 SignalConnectorType signalConnector8( mType, SIGNAL_VISIBILITY_CHANGED, &Actor::DoConnectSignal );


@@ -282,17 +287,9 @@ 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( 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_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_TABLE_END( DRAW_MODE )
 
 DALI_ENUM_TO_STRING_TABLE_BEGIN( RESIZE_POLICY )


@@ -408,7 +405,8 @@ void EmitVisibilityChangedSignalRecursively( ActorPtr actor, bool visible, Devel
 
 ActorPtr Actor::New()
 {
 
 ActorPtr Actor::New()
 {

-  ActorPtr actor( new Actor( BASIC ) );
+  // pass a reference to actor, actor does not own its node
+  ActorPtr actor( new Actor( BASIC, *CreateNode() ) );

 
   // Second-phase construction
   actor->Initialize();
 
   // Second-phase construction
   actor->Initialize();


@@ -416,6 +414,20 @@ ActorPtr Actor::New()
   return actor;
 }
 
   return actor;
 }
 

+const SceneGraph::Node* Actor::CreateNode()
+{
+  // create node. Nodes are owned by the update manager
+  SceneGraph::Node* node = SceneGraph::Node::New();
+  OwnerPointer< SceneGraph::Node > transferOwnership( node );
+  Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
+
+  DALI_ASSERT_ALWAYS( tls && "ThreadLocalStorage is null" );
+
+  AddNodeMessage( tls->GetUpdateManager(), transferOwnership );
+
+  return node;
+}
+

 const std::string& Actor::GetName() const
 {
   return mName;
 const std::string& Actor::GetName() const
 {
   return mName;


@@ -425,21 +437,18 @@ void Actor::SetName( const std::string& name )
 {
   mName = name;
 
 {
   mName = name;
 

-  if( NULL != mNode )
-  {
-    // ATTENTION: string for debug purposes is not thread safe.
-    DALI_LOG_SET_OBJECT_STRING( const_cast< SceneGraph::Node* >( mNode ), name );
-  }
+  // ATTENTION: string for debug purposes is not thread safe.
+  DALI_LOG_SET_OBJECT_STRING( const_cast< SceneGraph::Node* >( &GetNode() ), name );

 }
 
 uint32_t Actor::GetId() const
 {
 }
 
 uint32_t Actor::GetId() const
 {

-  return mId;
+  return GetNode().GetId();

 }
 
 }
 

-bool Actor::OnStage() const
+bool Actor::OnScene() const

 {
 {

-  return mIsOnStage;
+  return mIsOnScene;

 }
 
 Dali::Layer Actor::GetLayer()
 }
 
 Dali::Layer Actor::GetLayer()


@@ -609,7 +618,7 @@ ActorPtr Actor::FindChildByName( const std::string& actorName )
 ActorPtr Actor::FindChildById( const uint32_t id )
 {
   ActorPtr child = 0;
 ActorPtr Actor::FindChildById( const uint32_t id )
 {
   ActorPtr child = 0;

-  if( id == mId )
+  if( id == GetId() )

   {
     child = this;
   }
   {
     child = this;
   }


@@ -631,11 +640,8 @@ ActorPtr Actor::FindChildById( const uint32_t id )
 
 void Actor::SetParentOrigin( const Vector3& origin )
 {
 
 void Actor::SetParentOrigin( const Vector3& origin )
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SetParentOriginMessage( GetEventThreadServices(), *mNode, origin );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SetParentOriginMessage( GetEventThreadServices(), GetNode(), origin );

 
   // Cache for event-thread access
   if( !mParentOrigin )
 
   // Cache for event-thread access
   if( !mParentOrigin )


@@ -682,11 +688,8 @@ const Vector3& Actor::GetCurrentParentOrigin() const
 
 void Actor::SetAnchorPoint( const Vector3& anchor )
 {
 
 void Actor::SetAnchorPoint( const Vector3& anchor )
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SetAnchorPointMessage( GetEventThreadServices(), *mNode, anchor );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SetAnchorPointMessage( GetEventThreadServices(), GetNode(), anchor );

 
   // Cache for event-thread access
   if( !mAnchorPoint )
 
   // Cache for event-thread access
   if( !mAnchorPoint )


@@ -745,66 +748,46 @@ void Actor::SetPosition( const Vector3& position )
 {
   mTargetPosition = position;
 
 {
   mTargetPosition = position;
 

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, position );

 }
 
 void Actor::SetX( float x )
 {
   mTargetPosition.x = x;
 
 }
 
 void Actor::SetX( float x )
 {
   mTargetPosition.x = x;
 

-  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->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );

 }
 
 void Actor::SetY( float y )
 {
   mTargetPosition.y = y;
 
 }
 
 void Actor::SetY( float y )
 {
   mTargetPosition.y = y;
 

-  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->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );

 }
 
 void Actor::SetZ( float z )
 {
   mTargetPosition.z = z;
 
 }
 
 void Actor::SetZ( float z )
 {
   mTargetPosition.z = z;
 

-  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->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );

 }
 
 void Actor::TranslateBy( const Vector3& distance )
 {
   mTargetPosition += distance;
 
 }
 
 void Actor::TranslateBy( const Vector3& distance )
 {
   mTargetPosition += distance;
 

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mPosition, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelative, distance );

 }
 
 const Vector3& Actor::GetCurrentPosition() const
 {
 }
 
 const Vector3& Actor::GetCurrentPosition() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetPosition(GetEventThreadServices().GetEventBufferIndex());
-  }
-
-  return Vector3::ZERO;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetPosition(GetEventThreadServices().GetEventBufferIndex());

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


@@ -814,60 +797,37 @@ const Vector3& Actor::GetTargetPosition() const
 
 const Vector3& Actor::GetCurrentWorldPosition() const
 {
 
 const Vector3& Actor::GetCurrentWorldPosition() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
-  }
-
-  return Vector3::ZERO;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );

 }
 
 const Vector2 Actor::GetCurrentScreenPosition() const
 {
 }
 
 const Vector2 Actor::GetCurrentScreenPosition() const
 {

-  StagePtr stage = Stage::GetCurrent();
-  if( stage && OnStage() && NULL != mNode )
+  if( mScene && OnScene() )

   {
   {

-    Vector3 worldPosition =  mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
-    Vector3 cameraPosition = stage->GetDefaultCameraActor().mNode->GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+    Vector3 worldPosition =  GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );
+    Vector3 cameraPosition = mScene->GetDefaultCameraActor().GetNode().GetWorldPosition( GetEventThreadServices().GetEventBufferIndex() );

     worldPosition -= cameraPosition;
 
     Vector3 actorSize = GetCurrentSize() * GetCurrentWorldScale();
     worldPosition -= cameraPosition;
 
     Vector3 actorSize = GetCurrentSize() * GetCurrentWorldScale();

-    Vector2 halfStageSize( stage->GetSize() * 0.5f ); // World position origin is center of stage
+    Vector2 halfSceneSize( mScene->GetSize() * 0.5f ); // World position origin is center of scene

     Vector3 halfActorSize( actorSize * 0.5f );
     Vector3 anchorPointOffSet = halfActorSize - actorSize * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
 
     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( halfSceneSize.width + worldPosition.x - anchorPointOffSet.x,
+                    halfSceneSize.height + worldPosition.y - anchorPointOffSet.y );

   }
 
   return Vector2::ZERO;
 }
 
   }
 
   return Vector2::ZERO;
 }
 

-void Actor::SetPositionInheritanceMode( PositionInheritanceMode mode )
-{
-  // this flag is not animatable so keep the value
-  mPositionInheritanceMode = mode;
-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value
-    SetInheritPositionMessage( GetEventThreadServices(), *mNode, mode == INHERIT_PARENT_POSITION );
-  }
-}
-
-PositionInheritanceMode Actor::GetPositionInheritanceMode() const
-{
-  // Cached for event-thread access
-  return mPositionInheritanceMode;
-}
-

 void Actor::SetInheritPosition( bool inherit )
 {
 void Actor::SetInheritPosition( bool inherit )
 {

-  if( mInheritPosition != inherit && NULL != mNode )
+  if( mInheritPosition != inherit )

   {
   {

-    // non animateable so keep local copy
+    // non animatable so keep local copy

     mInheritPosition = inherit;
     mInheritPosition = inherit;

-    SetInheritPositionMessage( GetEventThreadServices(), *mNode, inherit );
+    SetInheritPositionMessage( GetEventThreadServices(), GetNode(), inherit );

   }
 }
 
   }
 }
 


@@ -890,11 +850,8 @@ void Actor::SetOrientation( const Quaternion& orientation )
 {
   mTargetOrientation = orientation;
 
 {
   mTargetOrientation = orientation;
 

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::Bake, orientation );

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


@@ -906,33 +863,20 @@ void Actor::RotateBy( const Quaternion& relativeRotation )
 {
   mTargetOrientation *= 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
-    SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, &mNode->mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformPropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mOrientation, &SceneGraph::TransformManagerPropertyHandler<Quaternion>::BakeRelative, relativeRotation );

 }
 
 const Quaternion& Actor::GetCurrentOrientation() const
 {
 }
 
 const Quaternion& Actor::GetCurrentOrientation() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetOrientation(GetEventThreadServices().GetEventBufferIndex());
-  }
-
-  return Quaternion::IDENTITY;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetOrientation(GetEventThreadServices().GetEventBufferIndex());

 }
 
 const Quaternion& Actor::GetCurrentWorldOrientation() const
 {
 }
 
 const Quaternion& Actor::GetCurrentWorldOrientation() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetWorldOrientation( GetEventThreadServices().GetEventBufferIndex() );
-  }
-
-  return Quaternion::IDENTITY;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetWorldOrientation( GetEventThreadServices().GetEventBufferIndex() );

 }
 
 void Actor::SetScale( float scale )
 }
 
 void Actor::SetScale( float scale )


@@ -949,88 +893,62 @@ void Actor::SetScale( const Vector3& scale )
 {
   mTargetScale = scale;
 
 {
   mTargetScale = scale;
 

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, scale );

 }
 
 void Actor::SetScaleX( float x )
 {
   mTargetScale.x = 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
-    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, x );

 }
 
 void Actor::SetScaleY( float y )
 {
   mTargetScale.y = 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
-    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, y );

 }
 
 void Actor::SetScaleZ( float z )
 {
   mTargetScale.z = 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
-    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, z );

 }
 
 void Actor::ScaleBy(const Vector3& relativeScale)
 {
   mTargetScale *= 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
-    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mScale, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeRelativeMultiply, relativeScale );

 }
 
 const Vector3& Actor::GetCurrentScale() const
 {
 }
 
 const Vector3& Actor::GetCurrentScale() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetScale(GetEventThreadServices().GetEventBufferIndex());
-  }
-
-  return Vector3::ONE;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetScale(GetEventThreadServices().GetEventBufferIndex());

 }
 
 const Vector3& Actor::GetCurrentWorldScale() const
 {
 }
 
 const Vector3& Actor::GetCurrentWorldScale() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetWorldScale( GetEventThreadServices().GetEventBufferIndex() );
-  }
-
-  return Vector3::ONE;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetWorldScale( GetEventThreadServices().GetEventBufferIndex() );

 }
 
 void Actor::SetInheritScale( bool inherit )
 {
 }
 
 void Actor::SetInheritScale( bool inherit )
 {

-
-  if( mInheritScale != inherit && NULL != mNode )
+  if( mInheritScale != inherit )

   {
   {

-    // non animateable so keep local copy
+    // non animatable so keep local copy

     mInheritScale = inherit;
     mInheritScale = inherit;

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

   }
 }
 
   }
 }
 


@@ -1041,12 +959,7 @@ bool Actor::IsScaleInherited() const
 
 Matrix Actor::GetCurrentWorldMatrix() const
 {
 
 Matrix Actor::GetCurrentWorldMatrix() const
 {

-  if( NULL != mNode )
-  {
-    return mNode->GetWorldMatrix(0);
-  }
-
-  return Matrix::IDENTITY;
+  return GetNode().GetWorldMatrix(0);

 }
 
 void Actor::SetVisible( bool visible )
 }
 
 void Actor::SetVisible( bool visible )


@@ -1056,35 +969,22 @@ void Actor::SetVisible( bool visible )
 
 bool Actor::IsVisible() const
 {
 
 bool Actor::IsVisible() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->IsVisible( GetEventThreadServices().GetEventBufferIndex() );
-  }
-
-  return true;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().IsVisible( GetEventThreadServices().GetEventBufferIndex() );

 }
 
 void Actor::SetOpacity( float opacity )
 {
   mTargetColor.a = 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
-    SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeW, opacity );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeW, opacity );

 }
 
 float Actor::GetCurrentOpacity() const
 {
 }
 
 float Actor::GetCurrentOpacity() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetOpacity(GetEventThreadServices().GetEventBufferIndex());
-  }
-
-  return 1.0f;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetOpacity(GetEventThreadServices().GetEventBufferIndex());

 }
 
 ClippingMode::Type Actor::GetClippingMode() const
 }
 
 ClippingMode::Type Actor::GetClippingMode() const


@@ -1099,77 +999,55 @@ uint32_t Actor::GetSortingDepth()
 
 const Vector4& Actor::GetCurrentWorldColor() const
 {
 
 const Vector4& Actor::GetCurrentWorldColor() const
 {

-  if( NULL != mNode )
-  {
-    return mNode->GetWorldColor( GetEventThreadServices().GetEventBufferIndex() );
-  }
-
-  return Color::WHITE;
+  return GetNode().GetWorldColor( GetEventThreadServices().GetEventBufferIndex() );

 }
 
 void Actor::SetColor( const Vector4& color )
 {
   mTargetColor = 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
-    SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::Bake, color );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::Bake, color );

 }
 
 void Actor::SetColorRed( float red )
 {
   mTargetColor.r = 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
-    SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeX, red );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeX, red );

 }
 
 void Actor::SetColorGreen( float green )
 {
   mTargetColor.g = 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
-    SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeY, green );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeY, green );

 }
 
 void Actor::SetColorBlue( float blue )
 {
   mTargetColor.b = 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
-    SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, &mNode->mColor, &AnimatableProperty<Vector4>::BakeZ, blue );
-  }
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mColor, &AnimatableProperty<Vector4>::BakeZ, blue );

 }
 
 const Vector4& Actor::GetCurrentColor() const
 {
 }
 
 const Vector4& Actor::GetCurrentColor() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetColor(GetEventThreadServices().GetEventBufferIndex());
-  }
-
-  return Color::WHITE;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetColor(GetEventThreadServices().GetEventBufferIndex());

 }
 
 void Actor::SetInheritOrientation( bool inherit )
 {
 }
 
 void Actor::SetInheritOrientation( bool inherit )
 {

-  if( mInheritOrientation != inherit && NULL != mNode)
+  if( mInheritOrientation != inherit )

   {
   {

-    // non animateable so keep local copy
+    // non animatable so keep local copy

     mInheritOrientation = inherit;
     mInheritOrientation = inherit;

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

   }
 }
 
   }
 }
 


@@ -1197,13 +1075,10 @@ const Vector3& Actor::GetSizeModeFactor() const
 
 void Actor::SetColorMode( ColorMode colorMode )
 {
 
 void Actor::SetColorMode( ColorMode colorMode )
 {

-  // non animateable so keep local copy
+  // non animatable so keep local copy

   mColorMode = colorMode;
   mColorMode = colorMode;

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value
-    SetColorModeMessage( GetEventThreadServices(), *mNode, colorMode );
-  }
+  // node is being used in a separate thread; queue a message to set the value
+  SetColorModeMessage( GetEventThreadServices(), GetNode(), colorMode );

 }
 
 ColorMode Actor::GetColorMode() const
 }
 
 ColorMode Actor::GetColorMode() const


@@ -1250,15 +1125,14 @@ void Actor::SetSizeInternal( const Vector3& size )
   // dont allow recursive loop
   DALI_ASSERT_ALWAYS( !mInsideOnSizeSet && "Cannot call SetSize from OnSizeSet" );
   // check that we have a node AND the new size width, height or depth is at least a little bit different from the old one
   // dont allow recursive loop
   DALI_ASSERT_ALWAYS( !mInsideOnSizeSet && "Cannot call SetSize from OnSizeSet" );
   // check that we have a node AND the new size width, height or depth is at least a little bit different from the old one

-  if( ( NULL != mNode )&&
-      ( ( fabsf( mTargetSize.width - size.width  ) > Math::MACHINE_EPSILON_1 )||
-        ( fabsf( mTargetSize.height- size.height ) > Math::MACHINE_EPSILON_1 )||
-        ( fabsf( mTargetSize.depth - size.depth  ) > Math::MACHINE_EPSILON_1 ) ) )
+  if( ( fabsf( mTargetSize.width - size.width  ) > Math::MACHINE_EPSILON_1 )||
+      ( fabsf( mTargetSize.height- size.height ) > Math::MACHINE_EPSILON_1 )||
+      ( fabsf( mTargetSize.depth - size.depth  ) > Math::MACHINE_EPSILON_1 ) )

   {
     mTargetSize = size;
 
   {
     mTargetSize = size;
 

-    // mNode is being used in a separate thread; queue a message to set the value & base value
-    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, &mNode->mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );
+    // node is being used in a separate thread; queue a message to set the value & base value
+    SceneGraph::NodeTransformPropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::Bake, mTargetSize );

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


@@ -1284,13 +1158,12 @@ void Actor::SetWidth( float width )
   {
     mTargetSize.width = width;
 
   {
     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 );
-    }
+    // node is being used in a separate thread; queue a message to set the value & base value
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeX, width );

   }
 
   }
 

+  mUseAnimatedSize &= ~AnimatedSizeFlag::WIDTH;
+

   RelayoutRequest();
 }
 
   RelayoutRequest();
 }
 


@@ -1305,13 +1178,12 @@ void Actor::SetHeight( float height )
   {
     mTargetSize.height = height;
 
   {
     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 );
-    }
+    // node is being used in a separate thread; queue a message to set the value & base value
+    SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeY, height );

   }
 
   }
 

+  mUseAnimatedSize &= ~AnimatedSizeFlag::HEIGHT;
+

   RelayoutRequest();
 }
 
   RelayoutRequest();
 }
 


@@ -1319,25 +1191,45 @@ void Actor::SetDepth( float depth )
 {
   mTargetSize.depth = depth;
 
 {
   mTargetSize.depth = depth;
 

-  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>::BakeZ, depth );
-  }
+  mUseAnimatedSize &= ~AnimatedSizeFlag::DEPTH;
+
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodeTransformComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mSize, &SceneGraph::TransformManagerPropertyHandler<Vector3>::BakeZ, depth );

 }
 
 Vector3 Actor::GetTargetSize() const
 {
   Vector3 size = mTargetSize;
 
 }
 
 Vector3 Actor::GetTargetSize() const
 {
   Vector3 size = mTargetSize;
 

-  // Should return preferred size if size is fixed as set by SetSize
-  if( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::FIXED )
+  if( mUseAnimatedSize & AnimatedSizeFlag::WIDTH )
+  {
+    // Should return animated size if size is animated
+    size.width = mAnimatedSize.width;
+  }
+  else
+  {
+    // Should return preferred size if size is fixed as set by SetSize
+    if( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::FIXED )
+    {
+      size.width = GetPreferredSize().width;
+    }
+  }
+
+  if( mUseAnimatedSize & AnimatedSizeFlag::HEIGHT )
+  {
+    size.height = mAnimatedSize.height;
+  }
+  else

   {
   {

-    size.width = GetPreferredSize().width;
+    if( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::FIXED )
+    {
+      size.height = GetPreferredSize().height;
+    }

   }
   }

-  if( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::FIXED )
+
+  if( mUseAnimatedSize & AnimatedSizeFlag::DEPTH )

   {
   {

-    size.height = GetPreferredSize().height;
+    size.depth = mAnimatedSize.depth;

   }
 
   return size;
   }
 
   return size;


@@ -1345,13 +1237,8 @@ Vector3 Actor::GetTargetSize() const
 
 const Vector3& Actor::GetCurrentSize() const
 {
 
 const Vector3& Actor::GetCurrentSize() const
 {

-  if( NULL != mNode )
-  {
-    // mNode is being used in a separate thread; copy the value from the previous update
-    return mNode->GetSize( GetEventThreadServices().GetEventBufferIndex() );
-  }
-
-  return Vector3::ZERO;
+  // node is being used in a separate thread; copy the value from the previous update
+  return GetNode().GetSize( GetEventThreadServices().GetEventBufferIndex() );

 }
 
 Vector3 Actor::GetNaturalSize() const
 }
 
 Vector3 Actor::GetNaturalSize() const


@@ -1462,6 +1349,9 @@ void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
   EnsureRelayoutData();
 
   mRelayoutData->sizeSetPolicy = policy;
   EnsureRelayoutData();
 
   mRelayoutData->sizeSetPolicy = policy;

+
+  // Trigger relayout on this control
+  RelayoutRequest();

 }
 
 SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
 }
 
 SizeScalePolicy::Type Actor::GetSizeScalePolicy() const


@@ -1574,7 +1464,7 @@ uint32_t Actor::AddRenderer( Renderer& renderer )
   uint32_t index = static_cast<uint32_t>( mRenderers->size() ); //  4,294,967,295 renderers per actor
   RendererPtr rendererPtr = RendererPtr( &renderer );
   mRenderers->push_back( rendererPtr );
   uint32_t index = static_cast<uint32_t>( mRenderers->size() ); //  4,294,967,295 renderers per actor
   RendererPtr rendererPtr = RendererPtr( &renderer );
   mRenderers->push_back( rendererPtr );

-  AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+  AttachRendererMessage( GetEventThreadServices(), GetNode(), renderer.GetRendererSceneObject() );

   return index;
 }
 
   return index;
 }
 


@@ -1610,7 +1500,7 @@ void Actor::RemoveRenderer( Renderer& renderer )
       if( (*iter).Get() == &renderer )
       {
         mRenderers->erase( iter );
       if( (*iter).Get() == &renderer )
       {
         mRenderers->erase( iter );

-        RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+        DetachRendererMessage( GetEventThreadServices(), GetNode(), renderer.GetRendererSceneObject() );

         break;
       }
     }
         break;
       }
     }


@@ -1622,7 +1512,7 @@ void Actor::RemoveRenderer( uint32_t index )
   if( index < GetRendererCount() )
   {
     RendererPtr renderer = ( *mRenderers )[ index ];
   if( index < GetRendererCount() )
   {
     RendererPtr renderer = ( *mRenderers )[ index ];

-    RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+    DetachRendererMessage( GetEventThreadServices(), GetNode(), renderer.Get()->GetRendererSceneObject() );

     mRenderers->erase( mRenderers->begin()+index );
   }
 }
     mRenderers->erase( mRenderers->begin()+index );
   }
 }


@@ -1636,11 +1526,9 @@ 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 ) && ( drawMode != DrawMode::STENCIL ) )
-  {
-    // mNode is being used in a separate thread; queue a message to set the value
-    SetDrawModeMessage( GetEventThreadServices(), *mNode, drawMode );
-  }
+
+  // node is being used in a separate thread; queue a message to set the value
+  SetDrawModeMessage( GetEventThreadServices(), GetNode(), drawMode );

 }
 
 DrawMode::Type Actor::GetDrawMode() const
 }
 
 DrawMode::Type Actor::GetDrawMode() const


@@ -1651,10 +1539,9 @@ DrawMode::Type Actor::GetDrawMode() const
 bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
 {
   // only valid when on-stage
 bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
 {
   // only valid when on-stage

-  StagePtr stage = Stage::GetCurrent();
-  if( stage && OnStage() )
+  if( mScene && OnScene() )

   {
   {

-    const RenderTaskList& taskList = stage->GetRenderTaskList();
+    const RenderTaskList& taskList = mScene->GetRenderTaskList();

 
     Vector2 converted( screenX, screenY );
 
 
     Vector2 converted( screenX, screenY );
 


@@ -1662,8 +1549,8 @@ bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float sc
     uint32_t taskCount = taskList.GetTaskCount();
     for( uint32_t i = taskCount; i > 0; --i )
     {
     uint32_t taskCount = taskList.GetTaskCount();
     for( uint32_t i = taskCount; i > 0; --i )
     {

-      Dali::RenderTask task = taskList.GetTask( i - 1 );
-      if( ScreenToLocal( Dali::GetImplementation( task ), localX, localY, screenX, screenY ) )
+      RenderTaskPtr task = taskList.GetTask( i - 1 );
+      if( ScreenToLocal( *task, localX, localY, screenX, screenY ) )

       {
         // found a task where this conversion was ok so return
         return true;
       {
         // found a task where this conversion was ok so return
         return true;


@@ -1677,7 +1564,7 @@ bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& l
 {
   bool retval = false;
   // only valid when on-stage
 {
   bool retval = false;
   // only valid when on-stage

-  if( OnStage() )
+  if( OnScene() )

   {
     CameraActor* camera = renderTask.GetCameraActor();
     if( camera )
   {
     CameraActor* camera = renderTask.GetCameraActor();
     if( camera )


@@ -1698,15 +1585,15 @@ bool Actor::ScreenToLocal( const RenderTask& renderTask, float& localX, float& l
 
 bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
 {
 
 bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
 {

-  // Early-out if mNode is NULL
-  if( !OnStage() )
+  // Early-out if not on stage
+  if( !OnScene() )

   {
     return false;
   }
 
   // Get the ModelView matrix
   Matrix modelView;
   {
     return false;
   }
 
   // Get the ModelView matrix
   Matrix modelView;

-  Matrix::Multiply( modelView, mNode->GetWorldMatrix(0), viewMatrix );
+  Matrix::Multiply( modelView, GetNode().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*/);


@@ -1809,8 +1696,8 @@ bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) con
    C = o dot o - r^2
    */
 
    C = o dot o - r^2
    */
 

-  // Early out if mNode is NULL
-  if( !mNode )
+  // Early-out if not on stage
+  if( !OnScene() )

   {
     return false;
   }
   {
     return false;
   }


@@ -1818,14 +1705,14 @@ bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) con
   BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
 
   // Transforms the ray to the local reference system. As the test is against a sphere, only the translation and scale are needed.
   BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
 
   // Transforms the ray to the local reference system. As the test is against a sphere, only the translation and scale are needed.

-  const Vector3& translation( mNode->GetWorldPosition( bufferIndex ) );
+  const Vector3& translation( GetNode().GetWorldPosition( bufferIndex ) );

   Vector3 rayOriginLocal( rayOrigin.x - translation.x, rayOrigin.y - translation.y, rayOrigin.z - translation.z );
 
   // Compute the radius is not needed, square radius it's enough.
   Vector3 rayOriginLocal( rayOrigin.x - translation.x, rayOrigin.y - translation.y, rayOrigin.z - translation.z );
 
   // Compute the radius is not needed, square radius it's enough.

-  const Vector3& size( mNode->GetSize( bufferIndex ) );
+  const Vector3& size( GetNode().GetSize( bufferIndex ) );

 
   // Scale the sphere.
 
   // Scale the sphere.

-  const Vector3& scale( mNode->GetWorldScale( bufferIndex ) );
+  const Vector3& scale( GetNode().GetWorldScale( bufferIndex ) );

 
   const float width = size.width * scale.width;
   const float height = size.height * scale.height;
 
   const float width = size.width * scale.width;
   const float height = size.height * scale.height;


@@ -1843,14 +1730,14 @@ bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vecto
 {
   bool hit = false;
 
 {
   bool hit = false;
 

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

   {
     // Transforms the ray to the local reference system.
     // Calculate the inverse of Model matrix
     Matrix invModelMatrix( false/*don't init*/);
 
     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() );

-    invModelMatrix = mNode->GetWorldMatrix(0);
+    invModelMatrix = GetNode().GetWorldMatrix(0);

     invModelMatrix.Invert();
 
     Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
     invModelMatrix.Invert();
 
     Vector4 rayOriginLocal( invModelMatrix * rayOrigin );


@@ -1866,7 +1753,7 @@ bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vecto
       // Ray travels distance * rayDirLocal to intersect with plane.
       distance = a / b;
 
       // Ray travels distance * rayDirLocal to intersect with plane.
       distance = a / b;
 

-      const Vector3& size = mNode->GetSize( bufferIndex );
+      const Vector3& size = GetNode().GetSize( bufferIndex );

 
       hitPointLocal.x = rayOriginLocal.x + rayDirLocal.x * distance + size.x * 0.5f;
       hitPointLocal.y = rayOriginLocal.y + rayDirLocal.y * distance + size.y * 0.5f;
 
       hitPointLocal.x = rayOriginLocal.x + rayDirLocal.x * distance + size.x * 0.5f;
       hitPointLocal.y = rayOriginLocal.y + rayDirLocal.y * distance + size.y * 0.5f;


@@ -1901,7 +1788,7 @@ bool Actor::IsKeyboardFocusable() const
 
 bool Actor::GetTouchRequired() const
 {
 
 bool Actor::GetTouchRequired() const
 {

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

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


@@ -1935,7 +1822,7 @@ bool Actor::IsGestureRequred( Gesture::Type type ) const
   return mGestureData && mGestureData->IsGestureRequred( type );
 }
 
   return mGestureData && mGestureData->IsGestureRequred( type );
 }
 

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

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


@@ -1945,22 +1832,10 @@ bool Actor::EmitTouchEventSignal( const TouchEvent& event, const Dali::TouchData
     consumed = mTouchSignal.Emit( handle, touch );
   }
 
     consumed = mTouchSignal.Emit( handle, touch );
   }
 

-  if( !mTouchedSignal.Empty() )
-  {
-    Dali::Actor handle( this );
-    consumed |= mTouchedSignal.Emit( handle, event );
-  }
-
-  if( !consumed )
-  {
-    // Notification for derived classes
-    consumed = OnTouchEvent( event ); // TODO
-  }
-

   return consumed;
 }
 
   return consumed;
 }
 

-bool Actor::EmitHoverEventSignal( const HoverEvent& event )
+bool Actor::EmitHoverEventSignal( const Dali::HoverEvent& event )

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


@@ -1979,7 +1854,7 @@ bool Actor::EmitHoverEventSignal( const HoverEvent& event )
   return consumed;
 }
 
   return consumed;
 }
 

-bool Actor::EmitWheelEventSignal( const WheelEvent& event )
+bool Actor::EmitWheelEventSignal( const Dali::WheelEvent& event )

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


@@ -2034,12 +1909,7 @@ void Actor::EmitChildRemovedSignal( Actor& child )
   }
 }
 
   }
 }
 

-Dali::Actor::TouchSignalType& Actor::TouchedSignal()
-{
-  return mTouchedSignal;
-}
-
-Dali::Actor::TouchDataSignalType& Actor::TouchSignal()
+Dali::Actor::TouchEventSignalType& Actor::TouchSignal()

 {
   return mTouchSignal;
 }
 {
   return mTouchSignal;
 }


@@ -2054,14 +1924,14 @@ Dali::Actor::WheelEventSignalType& Actor::WheelEventSignal()
   return mWheelEventSignal;
 }
 
   return mWheelEventSignal;
 }
 

-Dali::Actor::OnStageSignalType& Actor::OnStageSignal()
+Dali::Actor::OnSceneSignalType& Actor::OnSceneSignal()

 {
 {

-  return mOnStageSignal;
+  return mOnSceneSignal;

 }
 
 }
 

-Dali::Actor::OffStageSignalType& Actor::OffStageSignal()
+Dali::Actor::OffSceneSignalType& Actor::OffSceneSignal()

 {
 {

-  return mOffStageSignal;
+  return mOffSceneSignal;

 }
 
 Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
 }
 
 Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()


@@ -2099,11 +1969,7 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
   bool connected( true );
   Actor* actor = static_cast< Actor* >( object ); // TypeRegistry guarantees that this is the correct type.
 
   bool connected( true );
   Actor* actor = static_cast< Actor* >( object ); // TypeRegistry guarantees that this is the correct type.
 

-  if( 0 == signalName.compare( SIGNAL_TOUCHED ) )
-  {
-    actor->TouchedSignal().Connect( tracker, functor );
-  }
-  else if( 0 == signalName.compare( SIGNAL_HOVERED ) )
+  if( 0 == signalName.compare( SIGNAL_HOVERED ) )

   {
     actor->HoveredSignal().Connect( tracker, functor );
   }
   {
     actor->HoveredSignal().Connect( tracker, functor );
   }


@@ -2111,13 +1977,13 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
   {
     actor->WheelEventSignal().Connect( tracker, functor );
   }
   {
     actor->WheelEventSignal().Connect( tracker, functor );
   }

-  else if( 0 == signalName.compare( SIGNAL_ON_STAGE ) )
+  else if( 0 == signalName.compare( SIGNAL_ON_SCENE ) )

   {
   {

-    actor->OnStageSignal().Connect( tracker, functor );
+    actor->OnSceneSignal().Connect( tracker, functor );

   }
   }

-  else if( 0 == signalName.compare( SIGNAL_OFF_STAGE ) )
+  else if( 0 == signalName.compare( SIGNAL_OFF_SCENE ) )

   {
   {

-    actor->OffStageSignal().Connect( tracker, functor );
+    actor->OffSceneSignal().Connect( tracker, functor );

   }
   else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
   {
   }
   else if( 0 == signalName.compare( SIGNAL_ON_RELAYOUT ) )
   {


@@ -2152,21 +2018,21 @@ bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tra
   return connected;
 }
 
   return connected;
 }
 

-Actor::Actor( DerivedType derivedType )
-: mParent( NULL ),
+Actor::Actor( DerivedType derivedType, const SceneGraph::Node& node )
+: Object( &node ),
+  mScene( nullptr ),
+  mParent( NULL ),

   mChildren( NULL ),
   mRenderers( NULL ),
   mChildren( NULL ),
   mRenderers( NULL ),

-  mNode( NULL ),

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

-  mTouchedSignal(),

   mTouchSignal(),
   mHoveredSignal(),
   mWheelEventSignal(),
   mTouchSignal(),
   mHoveredSignal(),
   mWheelEventSignal(),

-  mOnStageSignal(),
-  mOffStageSignal(),
+  mOnSceneSignal(),
+  mOffSceneSignal(),

   mOnRelayoutSignal(),
   mVisibilityChangedSignal(),
   mLayoutDirectionChangedSignal(),
   mOnRelayoutSignal(),
   mVisibilityChangedSignal(),
   mLayoutDirectionChangedSignal(),


@@ -2178,20 +2044,21 @@ Actor::Actor( DerivedType derivedType )
   mTargetSize( Vector3::ZERO ),
   mTargetPosition( Vector3::ZERO ),
   mTargetScale( Vector3::ONE ),
   mTargetSize( Vector3::ZERO ),
   mTargetPosition( Vector3::ZERO ),
   mTargetScale( Vector3::ONE ),

+  mAnimatedSize( Vector3::ZERO ),

   mName(),
   mName(),

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

   mSortedDepth( 0u ),
   mDepth( 0u ),
   mSortedDepth( 0u ),
   mDepth( 0u ),

+  mUseAnimatedSize( AnimatedSizeFlag::CLEAR ),

   mIsRoot( ROOT_LAYER == derivedType ),
   mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),
   mIsRoot( ROOT_LAYER == derivedType ),
   mIsLayer( LAYER == derivedType || ROOT_LAYER == derivedType ),

-  mIsOnStage( false ),
+  mIsOnScene( false ),

   mSensitive( true ),
   mLeaveRequired( false ),
   mKeyboardFocusable( false ),
   mDerivedRequiresTouch( false ),
   mDerivedRequiresHover( false ),
   mDerivedRequiresWheelEvent( false ),
   mSensitive( true ),
   mLeaveRequired( false ),
   mKeyboardFocusable( false ),
   mDerivedRequiresTouch( false ),
   mDerivedRequiresHover( false ),
   mDerivedRequiresWheelEvent( false ),

-  mOnStageSignalled( false ),
+  mOnSceneSignalled( false ),

   mInsideOnSizeSet( false ),
   mInheritPosition( true ),
   mInheritOrientation( true ),
   mInsideOnSizeSet( false ),
   mInheritPosition( true ),
   mInheritOrientation( true ),


@@ -2199,9 +2066,9 @@ Actor::Actor( DerivedType derivedType )
   mPositionUsesAnchorPoint( true ),
   mVisible( true ),
   mInheritLayoutDirection( true ),
   mPositionUsesAnchorPoint( true ),
   mVisible( true ),
   mInheritLayoutDirection( true ),

+  mCaptureAllTouchAfterStart( false ),

   mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),
   mDrawMode( DrawMode::NORMAL ),
   mLayoutDirection( LayoutDirection::LEFT_TO_RIGHT ),
   mDrawMode( DrawMode::NORMAL ),

-  mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),

   mColorMode( Node::DEFAULT_COLOR_MODE ),
   mClippingMode( ClippingMode::DISABLED )
 {
   mColorMode( Node::DEFAULT_COLOR_MODE ),
   mClippingMode( ClippingMode::DISABLED )
 {


@@ -2209,11 +2076,6 @@ Actor::Actor( DerivedType derivedType )
 
 void Actor::Initialize()
 {
 
 void Actor::Initialize()
 {

-  // 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();
 
   GetEventThreadServices().RegisterObject( this );
   OnInitialize();
 
   GetEventThreadServices().RegisterObject( this );


@@ -2237,13 +2099,13 @@ Actor::~Actor()
   // 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() )
   {

-    if( NULL != mNode )
+    // Root layer will destroy its node in its own destructor
+    if ( !mIsRoot )

     {
     {

-      DestroyNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
-      mNode = NULL; // Node is about to be destroyed
-    }
+      DestroyNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );

 
 

-    GetEventThreadServices().UnregisterObject( this );
+      GetEventThreadServices().UnregisterObject( this );
+    }

   }
 
   // Cleanup optional gesture data
   }
 
   // Cleanup optional gesture data


@@ -2254,26 +2116,22 @@ Actor::~Actor()
   delete mAnchorPoint;
 
   // Delete optional relayout data
   delete mAnchorPoint;
 
   // Delete optional relayout data

-  if( mRelayoutData )
-  {
-    delete mRelayoutData;
-  }
+  delete mRelayoutData;

 }
 
 }
 

-void Actor::ConnectToStage( uint32_t parentDepth )
+void Actor::ConnectToScene( uint32_t parentDepth )

 {
   // This container is used instead of walking the Actor hierarchy.
 {
   // This container is used instead of walking the Actor hierarchy.

-  // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
+  // It protects us when the Actor hierarchy is modified during OnSceneConnectionExternal callbacks.

   ActorContainer connectionList;
 
   ActorContainer connectionList;
 

-  StagePtr stage = Stage::GetCurrent();
-  if( stage )
+  if( mScene )

   {
   {

-    stage->RequestRebuildDepthTree();
+    mScene->RequestRebuildDepthTree();

   }
 
   // This stage is atomic i.e. not interrupted by user callbacks.
   }
 
   // This stage is atomic i.e. not interrupted by user callbacks.

-  RecursiveConnectToStage( connectionList, parentDepth + 1 );
+  RecursiveConnectToScene( connectionList, parentDepth + 1 );

 
   // Notify applications about the newly connected actors.
   const ActorIter endIter = connectionList.end();
 
   // Notify applications about the newly connected actors.
   const ActorIter endIter = connectionList.end();


@@ -2285,17 +2143,17 @@ void Actor::ConnectToStage( uint32_t parentDepth )
   RelayoutRequest();
 }
 
   RelayoutRequest();
 }
 

-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t depth )
+void Actor::RecursiveConnectToScene( ActorContainer& connectionList, uint32_t depth )

 {
 {

-  DALI_ASSERT_ALWAYS( !OnStage() );
+  DALI_ASSERT_ALWAYS( !OnScene() );

 
 

-  mIsOnStage = true;
+  mIsOnScene = true;

   mDepth = static_cast< uint16_t >( depth ); // overflow ignored, not expected in practice
 
   ConnectToSceneGraph();
 
   // Notification for internal derived classes
   mDepth = static_cast< uint16_t >( depth ); // overflow ignored, not expected in practice
 
   ConnectToSceneGraph();
 
   // Notification for internal derived classes

-  OnStageConnectionInternal();
+  OnSceneConnectionInternal();

 
   // This stage is atomic; avoid emitting callbacks until all Actors are connected
   connectionList.push_back( ActorPtr( this ) );
 
   // This stage is atomic; avoid emitting callbacks until all Actors are connected
   connectionList.push_back( ActorPtr( this ) );


@@ -2306,7 +2164,8 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t de
     ActorConstIter endIter = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
     {
     ActorConstIter endIter = mChildren->end();
     for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
     {

-      (*iter)->RecursiveConnectToStage( connectionList, depth + 1 );
+      (*iter)->SetScene( *mScene );
+      (*iter)->RecursiveConnectToScene( connectionList, depth + 1 );

     }
   }
 }
     }
   }
 }


@@ -2315,17 +2174,14 @@ void Actor::RecursiveConnectToStage( ActorContainer& connectionList, uint32_t de
  * 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 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 recursive; the child calls ConnectToStage() for its children.
+ * This is recursive; the child calls ConnectToScene() for its children.

  */
 void Actor::ConnectToSceneGraph()
 {
  */
 void Actor::ConnectToSceneGraph()
 {

-  DALI_ASSERT_DEBUG( mNode != NULL); DALI_ASSERT_DEBUG( mParent != NULL); DALI_ASSERT_DEBUG( mParent->mNode != NULL );
+  DALI_ASSERT_DEBUG( mParent != NULL);

 
 

-  if( NULL != mNode )
-  {
-    // Reparent Node in next Update
-    ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
-  }
+  // Reparent Node in next Update
+  ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), mParent->GetNode(), GetNode() );

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


@@ -2337,22 +2193,22 @@ void Actor::ConnectToSceneGraph()
 void Actor::NotifyStageConnection()
 {
   // Actors can be removed (in a callback), before the on-stage stage is reported.
 void Actor::NotifyStageConnection()
 {
   // Actors can be removed (in a callback), before the on-stage stage is reported.

-  // The actor may also have been reparented, in which case mOnStageSignalled will be true.
-  if( OnStage() && !mOnStageSignalled )
+  // The actor may also have been reparented, in which case mOnSceneSignalled will be true.
+  if( OnScene() && !mOnSceneSignalled )

   {
     // Notification for external (CustomActor) derived classes
   {
     // Notification for external (CustomActor) derived classes

-    OnStageConnectionExternal( mDepth );
+    OnSceneConnectionExternal( mDepth );

 
 

-    if( !mOnStageSignal.Empty() )
+    if( !mOnSceneSignal.Empty() )

     {
       Dali::Actor handle( this );
     {
       Dali::Actor handle( this );

-      mOnStageSignal.Emit( handle );
+      mOnSceneSignal.Emit( handle );

     }
 
     // Guard against Remove during callbacks
     }
 
     // Guard against Remove during callbacks

-    if( OnStage() )
+    if( OnScene() )

     {
     {

-      mOnStageSignalled = true; // signal required next time Actor is removed
+      mOnSceneSignalled = true; // signal required next time Actor is removed

     }
   }
 }
     }
   }
 }


@@ -2360,13 +2216,12 @@ void Actor::NotifyStageConnection()
 void Actor::DisconnectFromStage()
 {
   // This container is used instead of walking the Actor hierachy.
 void Actor::DisconnectFromStage()
 {
   // This container is used instead of walking the Actor hierachy.

-  // It protects us when the Actor hierachy is modified during OnStageDisconnectionExternal callbacks.
+  // It protects us when the Actor hierachy is modified during OnSceneDisconnectionExternal callbacks.

   ActorContainer disconnectionList;
 
   ActorContainer disconnectionList;
 

-  StagePtr stage = Stage::GetCurrent();
-  if( stage )
+  if( mScene )

   {
   {

-    stage->RequestRebuildDepthTree();
+    mScene->RequestRebuildDepthTree();

   }
 
   // This stage is atomic i.e. not interrupted by user callbacks
   }
 
   // This stage is atomic i.e. not interrupted by user callbacks


@@ -2382,7 +2237,8 @@ void Actor::DisconnectFromStage()
 
 void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
 {
 
 void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
 {

-  DALI_ASSERT_ALWAYS( OnStage() );
+  // need to change state first so that internals relying on IsOnScene() inside OnSceneDisconnectionInternal() get the correct value
+  mIsOnScene = false;

 
   // Recursively disconnect children
   if( mChildren )
 
   // Recursively disconnect children
   if( mChildren )


@@ -2398,11 +2254,9 @@ void Actor::RecursiveDisconnectFromStage( ActorContainer& disconnectionList )
   disconnectionList.push_back( ActorPtr( this ) );
 
   // Notification for internal derived classes
   disconnectionList.push_back( ActorPtr( this ) );
 
   // Notification for internal derived classes

-  OnStageDisconnectionInternal();
+  OnSceneDisconnectionInternal();

 
   DisconnectFromSceneGraph();
 
   DisconnectFromSceneGraph();

-
-  mIsOnStage = false;

 }
 
 /**
 }
 
 /**


@@ -2418,23 +2272,23 @@ void Actor::DisconnectFromSceneGraph()
 void Actor::NotifyStageDisconnection()
 {
   // Actors can be added (in a callback), before the off-stage state is reported.
 void Actor::NotifyStageDisconnection()
 {
   // Actors can be added (in a callback), before the off-stage state is reported.

-  // Also if the actor was added & removed before mOnStageSignalled was set, then we don't notify here.
+  // Also if the actor was added & removed before mOnSceneSignalled was set, then we don't notify here.

   // only do this step if there is a stage, i.e. Core is not being shut down
   // only do this step if there is a stage, i.e. Core is not being shut down

-  if ( EventThreadServices::IsCoreRunning() && !OnStage() && mOnStageSignalled )
+  if ( EventThreadServices::IsCoreRunning() && !OnScene() && mOnSceneSignalled )

   {
     // Notification for external (CustomeActor) derived classes
   {
     // Notification for external (CustomeActor) derived classes

-    OnStageDisconnectionExternal();
+    OnSceneDisconnectionExternal();

 
 

-    if( !mOffStageSignal.Empty() )
+    if( !mOffSceneSignal.Empty() )

     {
       Dali::Actor handle( this );
     {
       Dali::Actor handle( this );

-      mOffStageSignal.Emit( handle );
+      mOffSceneSignal.Emit( handle );

     }
 
     // Guard against Add during callbacks
     }
 
     // Guard against Add during callbacks

-    if( !OnStage() )
+    if( !OnScene() )

     {
     {

-      mOnStageSignalled = false; // signal required next time Actor is added
+      mOnSceneSignalled = false; // signal required next time Actor is added

     }
   }
 }
     }
   }
 }


@@ -2443,9 +2297,9 @@ bool Actor::IsNodeConnected() const
 {
   bool connected( false );
 
 {
   bool connected( false );
 

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

   {
   {

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

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


@@ -2478,7 +2332,7 @@ void Actor::RebuildDepthTree()
 void Actor::DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int32_t& depthIndex )
 {
   mSortedDepth = depthIndex * DevelLayer::SIBLING_ORDER_MULTIPLIER;
 void Actor::DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneGraphNodeDepths, int32_t& depthIndex )
 {
   mSortedDepth = depthIndex * DevelLayer::SIBLING_ORDER_MULTIPLIER;

-  sceneGraphNodeDepths->Add( const_cast<SceneGraph::Node*>( mNode ), mSortedDepth );
+  sceneGraphNodeDepths->Add( const_cast<SceneGraph::Node*>( &GetNode() ), mSortedDepth );

 
   // Create/add to children of this node
   if( mChildren )
 
   // Create/add to children of this node
   if( mChildren )


@@ -2492,90 +2346,6 @@ void Actor::DepthTraverseActorTree( OwnerPointer<SceneGraph::NodeDepths>& sceneG
   }
 }
 
   }
 }
 

-uint32_t Actor::GetDefaultPropertyCount() const
-{
-  return DEFAULT_PROPERTY_COUNT;
-}
-
-void Actor::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
-{
-  indices.Reserve( DEFAULT_PROPERTY_COUNT );
-
-  for( int32_t i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
-  {
-    indices.PushBack( i );
-  }
-}
-
-const char* Actor::GetDefaultPropertyName( Property::Index index ) const
-{
-  if( index < DEFAULT_PROPERTY_COUNT )
-  {
-    return DEFAULT_PROPERTY_DETAILS[ index ].name;
-  }
-
-  return NULL;
-}
-
-Property::Index Actor::GetDefaultPropertyIndex( const std::string& name ) const
-{
-  Property::Index index = Property::INVALID_INDEX;
-
-  // Look for name in default properties
-  for( int32_t i = 0; i < DEFAULT_PROPERTY_COUNT; ++i )
-  {
-    const Internal::PropertyDetails* property = &DEFAULT_PROPERTY_DETAILS[ i ];
-    if( 0 == name.compare( property->name ) )
-    {
-      index = i;
-      break;
-    }
-  }
-
-  return index;
-}
-
-bool Actor::IsDefaultPropertyWritable( Property::Index index ) const
-{
-  if( index < DEFAULT_PROPERTY_COUNT )
-  {
-    return DEFAULT_PROPERTY_DETAILS[ index ].writable;
-  }
-
-  return false;
-}
-
-bool Actor::IsDefaultPropertyAnimatable( Property::Index index ) const
-{
-  if( index < DEFAULT_PROPERTY_COUNT )
-  {
-    return DEFAULT_PROPERTY_DETAILS[ index ].animatable;
-  }
-
-  return false;
-}
-
-bool Actor::IsDefaultPropertyAConstraintInput( Property::Index index ) const
-{
-  if( index < DEFAULT_PROPERTY_COUNT )
-  {
-    return DEFAULT_PROPERTY_DETAILS[ index ].constraintInput;
-  }
-
-  return false;
-}
-
-Property::Type Actor::GetDefaultPropertyType( Property::Index index ) const
-{
-  if( index < DEFAULT_PROPERTY_COUNT )
-  {
-    return DEFAULT_PROPERTY_DETAILS[ index ].type;
-  }
-
-  // index out of range...return Property::NONE
-  return Property::NONE;
-}
-

 void Actor::SetDefaultProperty( Property::Index index, const Property::Value& property )
 {
   switch( index )
 void Actor::SetDefaultProperty( Property::Index index, const Property::Value& property )
 {
   switch( index )


@@ -2658,7 +2428,15 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::SIZE:
     {
 
     case Dali::Actor::Property::SIZE:
     {

-      SetSize( property.Get< Vector3 >() );
+      Property::Type type = property.GetType();
+      if( type == Property::VECTOR2 )
+      {
+        SetSize( property.Get< Vector2 >() );
+      }
+      else if ( type == Property::VECTOR3 )
+      {
+        SetSize( property.Get< Vector3 >() );
+      }

       break;
     }
 
       break;
     }
 


@@ -2682,7 +2460,16 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::POSITION:
     {
 
     case Dali::Actor::Property::POSITION:
     {

-      SetPosition( property.Get< Vector3 >() );
+      Property::Type type = property.GetType();
+      if( type == Property::VECTOR2 )
+      {
+        Vector2 position = property.Get< Vector2 >();
+        SetPosition( Vector3( position.x, position.y, 0.0f ) );
+      }
+      else if ( type == Property::VECTOR3 )
+      {
+        SetPosition( property.Get< Vector3 >() );
+      }

       break;
     }
 
       break;
     }
 


@@ -2712,7 +2499,16 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::SCALE:
     {
 
     case Dali::Actor::Property::SCALE:
     {

-      SetScale( property.Get< Vector3 >() );
+      Property::Type type = property.GetType();
+      if( type == Property::FLOAT )
+      {
+        float scale = property.Get< float >();
+        SetScale( scale, scale, scale );
+      }
+      else if ( type == Property::VECTOR3 )
+      {
+        SetScale( property.Get< Vector3 >() );
+      }

       break;
     }
 
       break;
     }
 


@@ -2742,7 +2538,16 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
 
     case Dali::Actor::Property::COLOR:
     {
 
     case Dali::Actor::Property::COLOR:
     {

-      SetColor( property.Get< Vector4 >() );
+      Property::Type type = property.GetType();
+      if( type == Property::VECTOR3 )
+      {
+        Vector3 color = property.Get< Vector3 >();
+        SetColor( Vector4( color.r, color.g, color.b, 1.0f ) );
+      }
+      else if( type == Property::VECTOR4 )
+      {
+        SetColor( property.Get< Vector4 >() );
+      }

       break;
     }
 
       break;
     }
 


@@ -2765,7 +2570,7 @@ 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:
+    case Dali::Actor::Property::OPACITY:

     {
       float value;
       if( property.Get( value ) )
     {
       float value;
       if( property.Get( value ) )


@@ -2821,16 +2626,6 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
       break;
     }
 
       break;
     }
 

-    case Dali::Actor::Property::POSITION_INHERITANCE:
-    {
-      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:
     {
       DrawMode::Type mode = mDrawMode;
     case Dali::Actor::Property::DRAW_MODE:
     {
       DrawMode::Type mode = mDrawMode;


@@ -2870,7 +2665,7 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
     case Dali::Actor::Property::SIZE_SCALE_POLICY:
     {
       SizeScalePolicy::Type type = GetSizeScalePolicy();
     case Dali::Actor::Property::SIZE_SCALE_POLICY:
     {
       SizeScalePolicy::Type type = GetSizeScalePolicy();

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

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


@@ -2936,24 +2731,18 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
       if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
       {
         mClippingMode = convertedValue;
       if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
       {
         mClippingMode = convertedValue;

-        if( NULL != mNode )
-        {
-          SetClippingModeMessage( GetEventThreadServices(), *mNode, mClippingMode );
-        }
+        SetClippingModeMessage( GetEventThreadServices(), GetNode(), mClippingMode );

       }
       break;
     }
 
       }
       break;
     }
 

-    case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+    case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:

     {
       bool value = false;
       if( property.Get( value ) && value != mPositionUsesAnchorPoint )
       {
         mPositionUsesAnchorPoint = value;
     {
       bool value = false;
       if( property.Get( value ) && value != mPositionUsesAnchorPoint )
       {
         mPositionUsesAnchorPoint = value;

-        if( NULL != mNode )
-        {
-          SetPositionUsesAnchorPointMessage( GetEventThreadServices(), *mNode, mPositionUsesAnchorPoint );
-        }
+        SetPositionUsesAnchorPointMessage( GetEventThreadServices(), GetNode(), mPositionUsesAnchorPoint );

       }
       break;
     }
       }
       break;
     }


@@ -2980,6 +2769,32 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
       break;
     }
 
       break;
     }
 

+    case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
+    {
+      bool value = false;
+      if( property.Get( value ) )
+      {
+        SetKeyboardFocusable( value );
+      }
+      break;
+    }
+
+    case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+    {
+      SetUpdateSizeHint( property.Get< Vector2 >() );
+      break;
+    }
+
+    case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
+    {
+      bool boolValue = false;
+      if ( property.Get( boolValue ) )
+      {
+        mCaptureAllTouchAfterStart = boolValue;
+      }
+      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


@@ -2999,7 +2814,7 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property

-      SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+      SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );

 
       break;
     }
 
       break;
     }


@@ -3010,7 +2825,7 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property

-      SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+      SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<int>::Bake, value.Get<int>() );

 
       break;
     }
 
       break;
     }


@@ -3021,7 +2836,7 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property

-      SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+      SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<float>::Bake, value.Get<float>() );

 
       break;
     }
 
       break;
     }


@@ -3034,15 +2849,15 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       // property is being used in a separate thread; queue a message to set the property
       if(entry.componentIndex == 0)
       {
       // property is being used in a separate thread; queue a message to set the property
       if(entry.componentIndex == 0)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );

       }
       else if(entry.componentIndex == 1)
       {
       }
       else if(entry.componentIndex == 1)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );

       }
       else
       {
       }
       else
       {

-        SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+        SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );

       }
 
       break;
       }
 
       break;


@@ -3056,19 +2871,19 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       // property is being used in a separate thread; queue a message to set the property
       if(entry.componentIndex == 0)
       {
       // property is being used in a separate thread; queue a message to set the property
       if(entry.componentIndex == 0)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );

       }
       else if(entry.componentIndex == 1)
       {
       }
       else if(entry.componentIndex == 1)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );

       }
       else if(entry.componentIndex == 2)
       {
       }
       else if(entry.componentIndex == 2)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );

       }
       else
       {
       }
       else
       {

-        SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+        SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );

       }
 
       break;
       }
 
       break;


@@ -3082,23 +2897,23 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       // property is being used in a separate thread; queue a message to set the property
       if(entry.componentIndex == 0)
       {
       // property is being used in a separate thread; queue a message to set the property
       if(entry.componentIndex == 0)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );

       }
       else if(entry.componentIndex == 1)
       {
       }
       else if(entry.componentIndex == 1)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );

       }
       else if(entry.componentIndex == 2)
       {
       }
       else if(entry.componentIndex == 2)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );

       }
       else if(entry.componentIndex == 3)
       {
       }
       else if(entry.componentIndex == 3)
       {

-        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
+        SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );

       }
       else
       {
       }
       else
       {

-        SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), mNode, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+        SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );

       }
 
       break;
       }
 
       break;


@@ -3110,7 +2925,7 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property

-      SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Quaternion>::Bake,  value.Get<Quaternion>() );
+      SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Quaternion>::Bake,  value.Get<Quaternion>() );

 
       break;
     }
 
       break;
     }


@@ -3121,7 +2936,7 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property

-      SceneGraph::NodePropertyMessage<Matrix>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Matrix>::Bake,  value.Get<Matrix>() );
+      SceneGraph::NodePropertyMessage<Matrix>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Matrix>::Bake,  value.Get<Matrix>() );

 
       break;
     }
 
       break;
     }


@@ -3132,7 +2947,7 @@ void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property
       DALI_ASSERT_DEBUG( NULL != property );
 
       // property is being used in a separate thread; queue a message to set the property

-      SceneGraph::NodePropertyMessage<Matrix3>::Send( GetEventThreadServices(), mNode, property,&AnimatableProperty<Matrix3>::Bake,  value.Get<Matrix3>() );
+      SceneGraph::NodePropertyMessage<Matrix3>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Matrix3>::Bake,  value.Get<Matrix3>() );

 
       break;
     }
 
       break;
     }


@@ -3183,6 +2998,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( value.Get( mTargetSize ) )
           {
         {
           if( value.Get( mTargetSize ) )
           {

+            mAnimatedSize = mTargetSize;
+            mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3193,6 +3011,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( value.Get( mTargetSize.width ) )
           {
         {
           if( value.Get( mTargetSize.width ) )
           {

+            mAnimatedSize.width = mTargetSize.width;
+            mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3203,6 +3024,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( value.Get( mTargetSize.height ) )
           {
         {
           if( value.Get( mTargetSize.height ) )
           {

+            mAnimatedSize.height = mTargetSize.height;
+            mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3213,6 +3037,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( value.Get( mTargetSize.depth ) )
           {
         {
           if( value.Get( mTargetSize.depth ) )
           {

+            mAnimatedSize.depth = mTargetSize.depth;
+            mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3304,7 +3131,7 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         }
 
         case Dali::Actor::Property::COLOR_ALPHA:
         }
 
         case Dali::Actor::Property::COLOR_ALPHA:

-        case Dali::DevelActor::Property::OPACITY:
+        case Dali::Actor::Property::OPACITY:

         {
           value.Get( mTargetColor.a );
           break;
         {
           value.Get( mTargetColor.a );
           break;


@@ -3327,6 +3154,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( AdjustValue< Vector3 >( mTargetSize, value ) )
           {
         {
           if( AdjustValue< Vector3 >( mTargetSize, value ) )
           {

+            mAnimatedSize = mTargetSize;
+            mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3337,6 +3167,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( AdjustValue< float >( mTargetSize.width, value ) )
           {
         {
           if( AdjustValue< float >( mTargetSize.width, value ) )
           {

+            mAnimatedSize.width = mTargetSize.width;
+            mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3347,6 +3180,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( AdjustValue< float >( mTargetSize.height, value ) )
           {
         {
           if( AdjustValue< float >( mTargetSize.height, value ) )
           {

+            mAnimatedSize.height = mTargetSize.height;
+            mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3357,6 +3193,9 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         {
           if( AdjustValue< float >( mTargetSize.depth, value ) )
           {
         {
           if( AdjustValue< float >( mTargetSize.depth, value ) )
           {

+            mAnimatedSize.depth = mTargetSize.depth;
+            mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
+

             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }
             // Notify deriving classes
             OnSizeAnimation( animation, mTargetSize );
           }


@@ -3457,7 +3296,7 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
         }
 
         case Dali::Actor::Property::COLOR_ALPHA:
         }
 
         case Dali::Actor::Property::COLOR_ALPHA:

-        case Dali::DevelActor::Property::OPACITY:
+        case Dali::Actor::Property::OPACITY:

         {
           AdjustValue< float >( mTargetColor.a, value );
           break;
         {
           AdjustValue< float >( mTargetColor.a, value );
           break;


@@ -3474,128 +3313,65 @@ void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::In
   }
 }
 
   }
 }
 

-const SceneGraph::PropertyOwner* Actor::GetPropertyOwner() const
-{
-  return mNode;
-}
-
-const SceneGraph::PropertyOwner* Actor::GetSceneObject() const
-{
-  // This method should only return an object connected to the scene-graph
-  return OnStage() ? mNode : NULL;
-}
-

 const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
 {
 const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
 {

-  DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
-

   const PropertyBase* property( NULL );
 
   const PropertyBase* property( NULL );
 

-  // This method should only return a property of an object connected to the scene-graph
-  if( !OnStage() )
-  {
-    return property;
-  }
-
-  if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
-  {
-    AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
-    DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
-
-    property = animatable->GetSceneGraphProperty();
-  }
-  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" );
-
-    property = custom->GetSceneGraphProperty();
-  }
-  else if( NULL != mNode )
+  switch( index )

   {
   {

-    switch( index )
+    case Dali::Actor::Property::SIZE:        // FALLTHROUGH
+    case Dali::Actor::Property::SIZE_WIDTH:  // FALLTHROUGH
+    case Dali::Actor::Property::SIZE_HEIGHT: // FALLTHROUGH
+    case Dali::Actor::Property::SIZE_DEPTH:

     {
     {

-      case Dali::Actor::Property::SIZE:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::SIZE_WIDTH:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::SIZE_HEIGHT:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::SIZE_DEPTH:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::POSITION:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::POSITION_X:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::POSITION_Y:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::POSITION_Z:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::ORIENTATION:
-        property = &mNode->mOrientation;
-        break;
-
-      case Dali::Actor::Property::SCALE:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::SCALE_X:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::SCALE_Y:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::SCALE_Z:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::VISIBLE:
-        property = &mNode->mVisible;
-        break;
-
-      case Dali::Actor::Property::COLOR:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_RED:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_GREEN:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_BLUE:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_ALPHA:
-      case Dali::DevelActor::Property::OPACITY:
-        property = &mNode->mColor;
-        break;
-
-      default:
-        break;
+      property = &GetNode().mSize;
+      break;
+    }
+    case Dali::Actor::Property::POSITION:   // FALLTHROUGH
+    case Dali::Actor::Property::POSITION_X: // FALLTHROUGH
+    case Dali::Actor::Property::POSITION_Y: // FALLTHROUGH
+    case Dali::Actor::Property::POSITION_Z:
+    {
+      property = &GetNode().mPosition;
+      break;
+    }
+    case Dali::Actor::Property::ORIENTATION:
+    {
+      property = &GetNode().mOrientation;
+      break;
+    }
+    case Dali::Actor::Property::SCALE:   // FALLTHROUGH
+    case Dali::Actor::Property::SCALE_X: // FALLTHROUGH
+    case Dali::Actor::Property::SCALE_Y: // FALLTHROUGH
+    case Dali::Actor::Property::SCALE_Z:
+    {
+      property = &GetNode().mScale;
+      break;
+    }
+    case Dali::Actor::Property::VISIBLE:
+    {
+      property = &GetNode().mVisible;
+      break;
+    }
+    case Dali::Actor::Property::COLOR:       // FALLTHROUGH
+    case Dali::Actor::Property::COLOR_RED:   // FALLTHROUGH
+    case Dali::Actor::Property::COLOR_GREEN: // FALLTHROUGH
+    case Dali::Actor::Property::COLOR_BLUE:  // FALLTHROUGH
+    case Dali::Actor::Property::COLOR_ALPHA: // FALLTHROUGH
+    case Dali::Actor::Property::OPACITY:
+    {
+      property = &GetNode().mColor;
+      break;

     }
     }

+    default:
+    {
+      break;
+    }
+  }
+  if( !property )
+  {
+    // not our property, ask base
+    property = Object::GetSceneObjectAnimatableProperty( index );

   }
 
   return property;
   }
 
   return property;


@@ -3605,252 +3381,132 @@ const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index ind
 {
   const PropertyInputImpl* property( NULL );
 
 {
   const PropertyInputImpl* property( NULL );
 

-  // This method should only return a property of an object connected to the scene-graph
-  if( !OnStage() )
-  {
-    return property;
-  }
-
-  if ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX && index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )
-  {
-    AnimatablePropertyMetadata* animatable = RegisterAnimatableProperty( index );
-    DALI_ASSERT_ALWAYS( animatable && "Property index is invalid" );
-
-    property = animatable->GetSceneGraphProperty();
-  }
-  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" );
-    property = custom->GetSceneGraphProperty();
-  }
-  else if( NULL != mNode )
+  switch( index )

   {
   {

-    switch( index )
+    case Dali::Actor::Property::PARENT_ORIGIN:   // FALLTHROUGH
+    case Dali::Actor::Property::PARENT_ORIGIN_X: // FALLTHROUGH
+    case Dali::Actor::Property::PARENT_ORIGIN_Y: // FALLTHROUGH
+    case Dali::Actor::Property::PARENT_ORIGIN_Z:

     {
     {

-      case Dali::Actor::Property::PARENT_ORIGIN:
-        property = &mNode->mParentOrigin;
-        break;
-
-      case Dali::Actor::Property::PARENT_ORIGIN_X:
-        property = &mNode->mParentOrigin;
-        break;
-
-      case Dali::Actor::Property::PARENT_ORIGIN_Y:
-        property = &mNode->mParentOrigin;
-        break;
-
-      case Dali::Actor::Property::PARENT_ORIGIN_Z:
-        property = &mNode->mParentOrigin;
-        break;
-
-      case Dali::Actor::Property::ANCHOR_POINT:
-        property = &mNode->mAnchorPoint;
-        break;
-
-      case Dali::Actor::Property::ANCHOR_POINT_X:
-        property = &mNode->mAnchorPoint;
-        break;
-
-      case Dali::Actor::Property::ANCHOR_POINT_Y:
-        property = &mNode->mAnchorPoint;
-        break;
-
-      case Dali::Actor::Property::ANCHOR_POINT_Z:
-        property = &mNode->mAnchorPoint;
-        break;
-
-      case Dali::Actor::Property::SIZE:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::SIZE_WIDTH:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::SIZE_HEIGHT:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::SIZE_DEPTH:
-        property = &mNode->mSize;
-        break;
-
-      case Dali::Actor::Property::POSITION:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::POSITION_X:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::POSITION_Y:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::POSITION_Z:
-        property = &mNode->mPosition;
-        break;
-
-      case Dali::Actor::Property::WORLD_POSITION:
-        property = &mNode->mWorldPosition;
-        break;
-
-      case Dali::Actor::Property::WORLD_POSITION_X:
-        property = &mNode->mWorldPosition;
-        break;
-
-      case Dali::Actor::Property::WORLD_POSITION_Y:
-        property = &mNode->mWorldPosition;
-        break;
-
-      case Dali::Actor::Property::WORLD_POSITION_Z:
-        property = &mNode->mWorldPosition;
-        break;
-
-      case Dali::Actor::Property::ORIENTATION:
-        property = &mNode->mOrientation;
-        break;
-
-      case Dali::Actor::Property::WORLD_ORIENTATION:
-        property = &mNode->mWorldOrientation;
-        break;
-
-      case Dali::Actor::Property::SCALE:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::SCALE_X:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::SCALE_Y:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::SCALE_Z:
-        property = &mNode->mScale;
-        break;
-
-      case Dali::Actor::Property::WORLD_SCALE:
-        property = &mNode->mWorldScale;
-        break;
-
-      case Dali::Actor::Property::VISIBLE:
-        property = &mNode->mVisible;
-        break;
-
-      case Dali::Actor::Property::COLOR:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_RED:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_GREEN:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_BLUE:
-        property = &mNode->mColor;
-        break;
-
-      case Dali::Actor::Property::COLOR_ALPHA:
-      case Dali::DevelActor::Property::OPACITY:
-      {
-        property = &mNode->mColor;
-        break;
-      }
-
-      case Dali::Actor::Property::WORLD_COLOR:
-        property = &mNode->mWorldColor;
-        break;
-
-      case Dali::Actor::Property::WORLD_MATRIX:
-        property = &mNode->mWorldMatrix;
-        break;
-
-      case Dali::DevelActor::Property::CULLED:
-        property = &mNode->mCulled;
-        break;
-
-      default:
-        break;
+      property = &GetNode().mParentOrigin;
+      break;

     }
     }

+    case Dali::Actor::Property::ANCHOR_POINT:   // FALLTHROUGH
+    case Dali::Actor::Property::ANCHOR_POINT_X: // FALLTHROUGH
+    case Dali::Actor::Property::ANCHOR_POINT_Y: // FALLTHROUGH
+    case Dali::Actor::Property::ANCHOR_POINT_Z:
+    {
+      property = &GetNode().mAnchorPoint;
+      break;
+    }
+    case Dali::Actor::Property::WORLD_POSITION:   // FALLTHROUGH
+    case Dali::Actor::Property::WORLD_POSITION_X: // FALLTHROUGH
+    case Dali::Actor::Property::WORLD_POSITION_Y: // FALLTHROUGH
+    case Dali::Actor::Property::WORLD_POSITION_Z:
+    {
+      property = &GetNode().mWorldPosition;
+      break;
+    }
+    case Dali::Actor::Property::WORLD_ORIENTATION:
+    {
+      property = &GetNode().mWorldOrientation;
+      break;
+    }
+    case Dali::Actor::Property::WORLD_SCALE:
+    {
+      property = &GetNode().mWorldScale;
+      break;
+    }
+    case Dali::Actor::Property::WORLD_COLOR:
+    {
+      property = &GetNode().mWorldColor;
+      break;
+    }
+    case Dali::Actor::Property::WORLD_MATRIX:
+    {
+      property = &GetNode().mWorldMatrix;
+      break;
+    }
+    case Dali::Actor::Property::CULLED:
+    {
+      property = &GetNode().mCulled;
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
+  if( !property )
+  {
+    // reuse animatable property getter as animatable properties are inputs as well
+    // animatable property chains back to Object::GetSceneObjectInputProperty() so all properties get covered
+    property = GetSceneObjectAnimatableProperty( index );

   }
 
   return property;
 }
 
   }
 
   return property;
 }
 

-int Actor::GetPropertyComponentIndex( Property::Index index ) const
+int32_t Actor::GetPropertyComponentIndex( Property::Index index ) const

 {
 {

-  int componentIndex( Property::INVALID_COMPONENT_INDEX );
+  int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;

 
 

-  if ( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) )
+  switch( index )

   {
   {

-    // check whether the animatable property is registered already, if not then register one.
-    AnimatablePropertyMetadata* animatableProperty = RegisterAnimatableProperty(index);
-    if( animatableProperty )
+    case Dali::Actor::Property::PARENT_ORIGIN_X:
+    case Dali::Actor::Property::ANCHOR_POINT_X:
+    case Dali::Actor::Property::SIZE_WIDTH:
+    case Dali::Actor::Property::POSITION_X:
+    case Dali::Actor::Property::WORLD_POSITION_X:
+    case Dali::Actor::Property::SCALE_X:
+    case Dali::Actor::Property::COLOR_RED:

     {
     {

-      componentIndex = animatableProperty->componentIndex;
+      componentIndex = 0;
+      break;

     }
     }

-  }
-  else
-  {
-    switch( index )
-    {
-      case Dali::Actor::Property::PARENT_ORIGIN_X:
-      case Dali::Actor::Property::ANCHOR_POINT_X:
-      case Dali::Actor::Property::SIZE_WIDTH:
-      case Dali::Actor::Property::POSITION_X:
-      case Dali::Actor::Property::WORLD_POSITION_X:
-      case Dali::Actor::Property::SCALE_X:
-      case Dali::Actor::Property::COLOR_RED:
-      {
-        componentIndex = 0;
-        break;
-      }

 
 

-      case Dali::Actor::Property::PARENT_ORIGIN_Y:
-      case Dali::Actor::Property::ANCHOR_POINT_Y:
-      case Dali::Actor::Property::SIZE_HEIGHT:
-      case Dali::Actor::Property::POSITION_Y:
-      case Dali::Actor::Property::WORLD_POSITION_Y:
-      case Dali::Actor::Property::SCALE_Y:
-      case Dali::Actor::Property::COLOR_GREEN:
-      {
-        componentIndex = 1;
-        break;
-      }
+    case Dali::Actor::Property::PARENT_ORIGIN_Y:
+    case Dali::Actor::Property::ANCHOR_POINT_Y:
+    case Dali::Actor::Property::SIZE_HEIGHT:
+    case Dali::Actor::Property::POSITION_Y:
+    case Dali::Actor::Property::WORLD_POSITION_Y:
+    case Dali::Actor::Property::SCALE_Y:
+    case Dali::Actor::Property::COLOR_GREEN:
+    {
+      componentIndex = 1;
+      break;
+    }

 
 

-      case Dali::Actor::Property::PARENT_ORIGIN_Z:
-      case Dali::Actor::Property::ANCHOR_POINT_Z:
-      case Dali::Actor::Property::SIZE_DEPTH:
-      case Dali::Actor::Property::POSITION_Z:
-      case Dali::Actor::Property::WORLD_POSITION_Z:
-      case Dali::Actor::Property::SCALE_Z:
-      case Dali::Actor::Property::COLOR_BLUE:
-      {
-        componentIndex = 2;
-        break;
-      }
+    case Dali::Actor::Property::PARENT_ORIGIN_Z:
+    case Dali::Actor::Property::ANCHOR_POINT_Z:
+    case Dali::Actor::Property::SIZE_DEPTH:
+    case Dali::Actor::Property::POSITION_Z:
+    case Dali::Actor::Property::WORLD_POSITION_Z:
+    case Dali::Actor::Property::SCALE_Z:
+    case Dali::Actor::Property::COLOR_BLUE:
+    {
+      componentIndex = 2;
+      break;
+    }

 
 

-      case Dali::Actor::Property::COLOR_ALPHA:
-      case Dali::DevelActor::Property::OPACITY:
-      {
-        componentIndex = 3;
-        break;
-      }
+    case Dali::Actor::Property::COLOR_ALPHA:
+    case Dali::Actor::Property::OPACITY:
+    {
+      componentIndex = 3;
+      break;
+    }

 
 

-      default:
-      {
-        // Do nothing
-        break;
-      }
+    default:
+    {
+      // Do nothing
+      break;

     }
   }
     }
   }

+  if( Property::INVALID_COMPONENT_INDEX == componentIndex )
+  {
+    // ask base
+    componentIndex = Object::GetPropertyComponentIndex( index );
+  }

 
   return componentIndex;
 }
 
   return componentIndex;
 }


@@ -3863,11 +3519,13 @@ void Actor::SetParent( Actor* parent )
 
     mParent = parent;
 
 
     mParent = parent;
 

+    mScene = parent->mScene;
+

     if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
     if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction

-         parent->OnStage() )
+         parent->OnScene() )

     {
       // Instruct each actor to create a corresponding node in the scene graph
     {
       // Instruct each actor to create a corresponding node in the scene graph

-      ConnectToStage( parent->GetHierarchyDepth() );
+      ConnectToScene( parent->GetHierarchyDepth() );

     }
 
     // Resolve the name and index for the child properties if any
     }
 
     // Resolve the name and index for the child properties if any


@@ -3880,25 +3538,17 @@ void Actor::SetParent( Actor* parent )
     mParent = NULL;
 
     if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
     mParent = NULL;
 
     if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction

-         OnStage() )
+         OnScene() )

     {
     {

-      DALI_ASSERT_ALWAYS( mNode != NULL );
-
-      if( NULL != mNode )
-      {
-        // Disconnect the Node & its children from the scene-graph.
-        DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *mNode );
-      }
+      // Disconnect the Node & its children from the scene-graph.
+      DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );

 
       // Instruct each actor to discard pointers to the scene-graph
       DisconnectFromStage();
     }
 
       // Instruct each actor to discard pointers to the scene-graph
       DisconnectFromStage();
     }

-  }
-}

 
 

-SceneGraph::Node* Actor::CreateNode() const
-{
-  return Node::New( mId );
+    mScene = nullptr;
+  }

 }
 
 bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
 }
 
 bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )


@@ -3923,6 +3573,15 @@ bool Actor::DoAction( BaseObject* object, const std::string& actionName, const P
   return done;
 }
 
   return done;
 }
 

+Rect<> Actor::CalculateScreenExtents( ) const
+{
+  auto screenPosition = GetCurrentScreenPosition();
+  Vector3 size = GetCurrentSize() * GetCurrentWorldScale();
+  Vector3 anchorPointOffSet = size * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
+  Vector2 position = Vector2( screenPosition.x - anchorPointOffSet.x, screenPosition.y - anchorPointOffSet.y );
+  return { position.x, position.y, size.x, size.y };
+}
+

 bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
 {
   bool valueSet = true;
 bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
 {
   bool valueSet = true;


@@ -4086,7 +3745,7 @@ bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& valu
     }
 
     case Dali::Actor::Property::COLOR_ALPHA:
     }
 
     case Dali::Actor::Property::COLOR_ALPHA:

-    case Dali::DevelActor::Property::OPACITY:
+    case Dali::Actor::Property::OPACITY:

     {
       value = mTargetColor.a;
       break;
     {
       value = mTargetColor.a;
       break;


@@ -4130,19 +3789,13 @@ bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& valu
 
     case Dali::Actor::Property::COLOR_MODE:
     {
 
     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 );
+      value = GetColorMode();

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

-      value = Scripting::GetEnumerationName< DrawMode::Type >( GetDrawMode(), DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT );
+      value = GetDrawMode();

       break;
     }
 
       break;
     }
 


@@ -4166,7 +3819,7 @@ bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& valu
 
     case Dali::Actor::Property::SIZE_SCALE_POLICY:
     {
 
     case Dali::Actor::Property::SIZE_SCALE_POLICY:
     {

-      value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT );
+      value = GetSizeScalePolicy();

       break;
     }
 
       break;
     }
 


@@ -4214,13 +3867,13 @@ bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& valu
       break;
     }
 
       break;
     }
 

-    case Dali::DevelActor::Property::SCREEN_POSITION:
+    case Dali::Actor::Property::SCREEN_POSITION:

     {
       value = GetCurrentScreenPosition();
       break;
     }
 
     {
       value = GetCurrentScreenPosition();
       break;
     }
 

-    case Dali::DevelActor::Property::POSITION_USES_ANCHOR_POINT:
+    case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:

     {
       value = mPositionUsesAnchorPoint;
       break;
     {
       value = mPositionUsesAnchorPoint;
       break;


@@ -4238,6 +3891,48 @@ bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& valu
       break;
     }
 
       break;
     }
 

+    case Dali::Actor::Property::ID:
+    {
+      value = static_cast<int>( GetId() );
+      break;
+    }
+
+    case Dali::Actor::Property::HIERARCHY_DEPTH:
+    {
+      value = GetHierarchyDepth();
+      break;
+    }
+
+    case Dali::Actor::Property::IS_ROOT:
+    {
+      value = IsRoot();
+      break;
+    }
+
+    case Dali::Actor::Property::IS_LAYER:
+    {
+      value = IsLayer();
+      break;
+    }
+
+    case Dali::Actor::Property::CONNECTED_TO_SCENE:
+    {
+      value = OnScene();
+      break;
+    }
+
+    case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
+    {
+      value = IsKeyboardFocusable();
+      break;
+    }
+
+    case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
+    {
+      value = mCaptureAllTouchAfterStart;
+      break;
+    }
+

     default:
     {
       // Must be a scene-graph only property
     default:
     {
       // Must be a scene-graph only property


@@ -4394,7 +4089,7 @@ bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& val
     }
 
     case Dali::Actor::Property::COLOR_ALPHA:
     }
 
     case Dali::Actor::Property::COLOR_ALPHA:

-    case Dali::DevelActor::Property::OPACITY:
+    case Dali::Actor::Property::OPACITY:

     {
       value = GetCurrentColor().a;
       break;
     {
       value = GetCurrentColor().a;
       break;


@@ -4418,9 +4113,15 @@ bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& val
       break;
     }
 
       break;
     }
 

-    case DevelActor::Property::CULLED:
+    case Dali::Actor::Property::CULLED:
+    {
+      value = GetNode().IsCulled( GetEventThreadServices().GetEventBufferIndex() );
+      break;
+    }
+
+    case Dali::DevelActor::Property::UPDATE_SIZE_HINT:

     {
     {

-      value = mNode->IsCulled( GetEventThreadServices().GetEventBufferIndex() );
+      value = GetUpdateSizeHint();

       break;
     }
 
       break;
     }
 


@@ -4638,12 +4339,12 @@ float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type d
 
     case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
     {
 
     case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
     {

-      return GetLatestSize( dimension ) * GetDimensionValue( child.GetSizeModeFactor(), dimension );
+      return GetLatestSize( dimension ) * GetDimensionValue( child.GetProperty< Vector3 >( Dali::Actor::Property::SIZE_MODE_FACTOR ), dimension );

     }
 
     case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
     {
     }
 
     case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
     {

-      return GetLatestSize( dimension ) + GetDimensionValue( child.GetSizeModeFactor(), dimension );
+      return GetLatestSize( dimension ) + GetDimensionValue( child.GetProperty< Vector3 >( Dali::Actor::Property::SIZE_MODE_FACTOR ), dimension );

     }
 
     default:
     }
 
     default:


@@ -5086,18 +4787,24 @@ void Actor::SetPreferredSize( const Vector2& size )
 {
   EnsureRelayoutData();
 
 {
   EnsureRelayoutData();
 

-  if( size.width > 0.0f )
+  // If valid width or height, then set the resize policy to FIXED
+  // A 0 width or height may also be required so if the resize policy has not been changed, i.e. is still set to DEFAULT,
+  // then change to FIXED as well
+
+  if( size.width > 0.0f || GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DEFAULT )

   {
     SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
   }
 
   {
     SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
   }
 

-  if( size.height > 0.0f )
+  if( size.height > 0.0f || GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DEFAULT )

   {
     SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
   }
 
   mRelayoutData->preferredSize = size;
 
   {
     SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
   }
 
   mRelayoutData->preferredSize = size;
 

+  mUseAnimatedSize = AnimatedSizeFlag::CLEAR;
+

   RelayoutRequest();
 }
 
   RelayoutRequest();
 }
 


@@ -5182,10 +4889,10 @@ void Actor::SetVisibleInternal( bool visible, SendMessage::Type sendMessage )
 {
   if( mVisible != visible )
   {
 {
   if( mVisible != visible )
   {

-    if( sendMessage == SendMessage::TRUE && NULL != mNode )
+    if( sendMessage == SendMessage::TRUE )

     {
     {

-      // 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 );
+      // node is being used in a separate thread; queue a message to set the value & base value
+      SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mVisible, &AnimatableProperty<bool>::Bake, visible );

     }
 
     mVisible = visible;
     }
 
     mVisible = visible;


@@ -5249,12 +4956,11 @@ uint32_t Actor::GetSiblingOrder() const
 
 void Actor::RequestRebuildDepthTree()
 {
 
 void Actor::RequestRebuildDepthTree()
 {

-  if( mIsOnStage )
+  if( mIsOnScene )

   {
   {

-    StagePtr stage = Stage::GetCurrent();
-    if( stage )
+    if( mScene )

     {
     {

-      stage->RequestRebuildDepthTree();
+      mScene->RequestRebuildDepthTree();

     }
   }
 }
     }
   }
 }


@@ -5438,6 +5144,16 @@ void Actor::LowerBelow( Internal::Actor& target )
   }
 }
 
   }
 }
 

+void Actor::SetScene( Scene& scene )
+{
+  mScene = &scene;
+}
+
+Scene& Actor::GetScene() const
+{
+  return *mScene;
+}
+

 void Actor::SetInheritLayoutDirection( bool inherit )
 {
   if( mInheritLayoutDirection != inherit )
 void Actor::SetInheritLayoutDirection( bool inherit )
 {
   if( mInheritLayoutDirection != inherit )


@@ -5478,6 +5194,19 @@ void Actor::InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirec
   }
 }
 
   }
 }
 

+void Actor::SetUpdateSizeHint( const Vector2& updateSizeHint )
+{
+  // node is being used in a separate thread; queue a message to set the value & base value
+  SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mUpdateSizeHint, &AnimatableProperty<Vector3>::Bake, Vector3(updateSizeHint.width, updateSizeHint.height, 0.f ) );
+}
+
+Vector2 Actor::GetUpdateSizeHint() const
+{
+  // node is being used in a separate thread, the value from the previous update is the same, set by user
+  Vector3 updateSizeHint = GetNode().GetUpdateSizeHint();
+  return Vector2( updateSizeHint.width, updateSizeHint.height );
+}
+

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