Merge "Size negotiation patch 3: Scope size negotiation enums" into tizen

diff --combined dali/internal/event/actors/actor-impl.cpp
index ff21ca6,b705387..ccb920a
--- 1/dali/internal/event/actors/actor-impl.cpp
--- 2/dali/internal/event/actors/actor-impl.cpp
+++ b/dali/internal/event/actors/actor-impl.cpp
@@@ -22,7 -22,6 +22,7 @@@
  #include <cmath>
  #include <algorithm>
  #include <cfloat>
 +#include <cstring> // for strcmp
  
  // INTERNAL INCLUDES
  
@@@ -67,6 -66,35 +67,35 @@@ using Dali::Internal::SceneGraph::Prope
  
  namespace Dali
  {
+ namespace ResizePolicy
+ {
+ 
+ namespace
+ {
+ DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( FIXED )
+ DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
+ DALI_ENUM_TO_STRING( FILL_TO_PARENT )
+ DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
+ DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
+ DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
+ DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
+ DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
+ DALI_ENUM_TO_STRING_TABLE_END( Type )
+ 
+ } // unnamed namespace
+ } // ResizePolicy
+ 
+ namespace SizeScalePolicy
+ {
+ namespace
+ {
+ // Enumeration to / from string conversion tables
+ DALI_ENUM_TO_STRING_TABLE_BEGIN( Type )DALI_ENUM_TO_STRING( USE_SIZE_SET )
+ DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
+ DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
+ DALI_ENUM_TO_STRING_TABLE_END( Type )
+ } // unnamed namespace
+ } // SizeScalePolicy
  
  namespace Internal
  {
@@@ -80,41 -108,41 +109,41 @@@ ActorContainer Actor::mNullChildren
  struct Actor::RelayoutData
  {
    RelayoutData()
-       : sizeModeFactor( Vector3::ONE ), preferredSize( Vector2::ZERO ), sizeSetPolicy( USE_SIZE_SET ), relayoutEnabled( false ), insideRelayout( false )
+       : sizeModeFactor( Vector3::ONE ), preferredSize( Vector2::ZERO ), sizeSetPolicy( SizeScalePolicy::USE_SIZE_SET ), relayoutEnabled( false ), insideRelayout( false )
    {
      // Set size negotiation defaults
-     for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+     for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
      {
-       resizePolicies[ i ] = FIXED;
+       resizePolicies[ i ] = ResizePolicy::FIXED;
        negotiatedDimensions[ i ] = 0.0f;
        dimensionNegotiated[ i ] = false;
        dimensionDirty[ i ] = false;
-       dimensionDependencies[ i ] = ALL_DIMENSIONS;
+       dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
        dimensionPadding[ i ] = Vector2( 0.0f, 0.0f );
        minimumSize[ i ] = 0.0f;
        maximumSize[ i ] = FLT_MAX;
      }
    }
  
-   ResizePolicy resizePolicies[ DIMENSION_COUNT ];      ///< Resize policies
+   ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ];      ///< Resize policies
  
-   Dimension dimensionDependencies[ DIMENSION_COUNT ];  ///< A list of dimension dependencies
+   Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ];  ///< A list of dimension dependencies
  
-   Vector2 dimensionPadding[ DIMENSION_COUNT ];         ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
+   Vector2 dimensionPadding[ Dimension::DIMENSION_COUNT ];         ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
  
-   float negotiatedDimensions[ DIMENSION_COUNT ];       ///< Storage for when a dimension is negotiated but before set on actor
+   float negotiatedDimensions[ Dimension::DIMENSION_COUNT ];       ///< Storage for when a dimension is negotiated but before set on actor
  
-   float minimumSize[ DIMENSION_COUNT ];                ///< The minimum size an actor can be
-   float maximumSize[ DIMENSION_COUNT ];                ///< The maximum size an actor can be
+   float minimumSize[ Dimension::DIMENSION_COUNT ];                ///< The minimum size an actor can be
+   float maximumSize[ Dimension::DIMENSION_COUNT ];                ///< The maximum size an actor can be
  
-   bool dimensionNegotiated[ DIMENSION_COUNT ];         ///< Has the dimension been negotiated
-   bool dimensionDirty[ DIMENSION_COUNT ];              ///< Flags indicating whether the layout dimension is dirty or not
+   bool dimensionNegotiated[ Dimension::DIMENSION_COUNT ];         ///< Has the dimension been negotiated
+   bool dimensionDirty[ Dimension::DIMENSION_COUNT ];              ///< Flags indicating whether the layout dimension is dirty or not
  
    Vector3 sizeModeFactor;                              ///< Factor of size used for certain SizeModes
  
    Vector2 preferredSize;                               ///< The preferred size of the actor
  
-   SizeScalePolicy sizeSetPolicy :3;            ///< Policy to apply when setting size. Enough room for the enum
+   SizeScalePolicy::Type sizeSetPolicy :3;            ///< Policy to apply when setting size. Enough room for the enum
  
    bool relayoutEnabled :1;                   ///< Flag to specify if this actor should be included in size negotiation or not (defaults to true)
    bool insideRelayout :1;                    ///< Locking flag to prevent recursive relayouts on size set
@@@ -221,23 -249,6 +250,6 @@@ const char* const SIGNAL_OFF_STAGE = "o
  const char* const ACTION_SHOW = "show";
  const char* const ACTION_HIDE = "hide";
  
- // Enumeration to / from string conversion tables
- 
- DALI_ENUM_TO_STRING_TABLE_BEGIN( ResizePolicy )DALI_ENUM_TO_STRING( FIXED )
- DALI_ENUM_TO_STRING( USE_NATURAL_SIZE )
- DALI_ENUM_TO_STRING( FILL_TO_PARENT )
- DALI_ENUM_TO_STRING( SIZE_RELATIVE_TO_PARENT )
- DALI_ENUM_TO_STRING( SIZE_FIXED_OFFSET_FROM_PARENT )
- DALI_ENUM_TO_STRING( FIT_TO_CHILDREN )
- DALI_ENUM_TO_STRING( DIMENSION_DEPENDENCY )
- DALI_ENUM_TO_STRING( USE_ASSIGNED_SIZE )
- DALI_ENUM_TO_STRING_TABLE_END( ResizePolicy )
- 
- DALI_ENUM_TO_STRING_TABLE_BEGIN( SizeScalePolicy )DALI_ENUM_TO_STRING( USE_SIZE_SET )
- DALI_ENUM_TO_STRING( FIT_WITH_ASPECT_RATIO )
- DALI_ENUM_TO_STRING( FILL_WITH_ASPECT_RATIO )
- DALI_ENUM_TO_STRING_TABLE_END( SizeScalePolicy )
- 
  BaseHandle CreateActor()
  {
    return Dali::Actor::New();
@@@ -260,16 -271,16 +272,16 @@@ TypeAction a2( mType, ACTION_HIDE, &Act
   * @param[in] dimension The dimension to extract
   * @return Return the value for the dimension
   */
- float GetDimensionValue( const Vector2& values, Dimension dimension )
+ float GetDimensionValue( const Vector2& values, Dimension::Type dimension )
  {
    switch( dimension )
    {
-     case WIDTH:
+     case Dimension::WIDTH:
      {
        return values.width;
      }
  
-     case HEIGHT:
+     case Dimension::HEIGHT:
      {
        return values.height;
      }
@@@ -290,7 -301,7 +302,7 @@@
   * @param[in] dimension The dimension to extract
   * @return Return the value for the dimension
   */
- float GetDimensionValue( const Vector3& values, Dimension dimension )
+ float GetDimensionValue( const Vector3& values, Dimension::Type dimension )
  {
    return GetDimensionValue( values.GetVectorXY(), dimension );
  }
@@@ -728,6 -739,8 +740,8 @@@ void Actor::SetPosition( float x, floa
  
  void Actor::SetPosition( const Vector3& position )
  {
+   mTargetPosition = position;
+ 
    if( NULL != mNode )
    {
      // mNode is being used in a separate thread; queue a message to set the value & base value
@@@ -737,6 -750,8 +751,8 @@@
  
  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
@@@ -746,6 -761,8 +762,8 @@@
  
  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
@@@ -755,6 -772,8 +773,8 @@@
  
  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
@@@ -764,6 -783,8 +784,8 @@@
  
  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
@@@ -782,6 -803,11 +804,11 @@@ const Vector3& Actor::GetCurrentPositio
    return Vector3::ZERO;
  }
  
+ const Vector3& Actor::GetTargetPosition() const
+ {
+   return mTargetPosition;
+ }
+ 
  const Vector3& Actor::GetCurrentWorldPosition() const
  {
    if( NULL != mNode )
@@@ -1266,11 -1292,11 +1293,11 @@@ Vector3 Actor::GetNaturalSize() cons
    return Vector3( 0.0f, 0.0f, 0.0f );
  }
  
- void Actor::SetResizePolicy( ResizePolicy policy, Dimension dimension )
+ void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -1278,16 -1304,16 +1305,16 @@@
      }
    }
  
-   if( policy == DIMENSION_DEPENDENCY )
+   if( policy == ResizePolicy::DIMENSION_DEPENDENCY )
    {
-     if( dimension & WIDTH )
+     if( dimension & Dimension::WIDTH )
      {
-       SetDimensionDependency( WIDTH, HEIGHT );
+       SetDimensionDependency( Dimension::WIDTH, Dimension::HEIGHT );
      }
  
-     if( dimension & HEIGHT )
+     if( dimension & Dimension::HEIGHT )
      {
-       SetDimensionDependency( HEIGHT, WIDTH );
+       SetDimensionDependency( Dimension::HEIGHT, Dimension::WIDTH );
      }
    }
  
@@@ -1297,12 -1323,12 +1324,12 @@@
    RelayoutRequest();
  }
  
- ResizePolicy Actor::GetResizePolicy( Dimension dimension ) const
+ ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
    // If more than one dimension is requested, just return the first one found
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) )
      {
@@@ -1310,28 -1336,28 +1337,28 @@@
      }
    }
  
-   return FIXED;   // Default
+   return ResizePolicy::FIXED;   // Default
  }
  
- void Actor::SetSizeScalePolicy( SizeScalePolicy policy )
+ void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
  {
    EnsureRelayoutData();
  
    mRelayoutData->sizeSetPolicy = policy;
  }
  
- SizeScalePolicy Actor::GetSizeScalePolicy() const
+ SizeScalePolicy::Type Actor::GetSizeScalePolicy() const
  {
    EnsureRelayoutData();
  
    return mRelayoutData->sizeSetPolicy;
  }
  
- void Actor::SetDimensionDependency( Dimension dimension, Dimension dependency )
+ void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -1340,12 -1366,12 +1367,12 @@@
    }
  }
  
- Dimension Actor::GetDimensionDependency( Dimension dimension ) const
+ Dimension::Type Actor::GetDimensionDependency( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
    // If more than one dimension is requested, just return the first one found
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) )
      {
@@@ -1353,7 -1379,7 +1380,7 @@@
      }
    }
  
-   return ALL_DIMENSIONS;   // Default
+   return Dimension::ALL_DIMENSIONS;   // Default
  }
  
  void Actor::SetRelayoutEnabled( bool relayoutEnabled )
@@@ -1375,11 -1401,11 +1402,11 @@@ bool Actor::IsRelayoutEnabled() cons
    return mRelayoutData && mRelayoutData->relayoutEnabled;
  }
  
- void Actor::SetLayoutDirty( bool dirty, Dimension dimension )
+ void Actor::SetLayoutDirty( bool dirty, Dimension::Type dimension )
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -1388,11 -1414,11 +1415,11 @@@
    }
  }
  
- bool Actor::IsLayoutDirty( Dimension dimension ) const
+ bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
      {
@@@ -1403,14 -1429,14 +1430,14 @@@
    return false;
  }
  
- bool Actor::RelayoutPossible( Dimension dimension ) const
+ bool Actor::RelayoutPossible( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
    return mRelayoutData->relayoutEnabled && !IsLayoutDirty( dimension );
  }
  
- bool Actor::RelayoutRequired( Dimension dimension ) const
+ bool Actor::RelayoutRequired( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
@@@ -2838,19 -2864,19 +2865,19 @@@ void Actor::SetDefaultProperty( Propert
  
      case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
      {
-       SetResizePolicy( Scripting::GetEnumeration< ResizePolicy >( property.Get< std::string >().c_str(), ResizePolicyTable, ResizePolicyTableCount ), WIDTH );
+       SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::WIDTH );
        break;
      }
  
      case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
      {
-       SetResizePolicy( Scripting::GetEnumeration< ResizePolicy >( property.Get< std::string >().c_str(), ResizePolicyTable, ResizePolicyTableCount ), HEIGHT );
+       SetResizePolicy( Scripting::GetEnumeration< ResizePolicy::Type >( property.Get< std::string >().c_str(), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount ), Dimension::HEIGHT );
        break;
      }
  
      case Dali::Actor::Property::SIZE_SCALE_POLICY:
      {
-       SetSizeScalePolicy( Scripting::GetEnumeration< SizeScalePolicy >( property.Get< std::string >().c_str(), SizeScalePolicyTable, SizeScalePolicyTableCount ) );
+       SetSizeScalePolicy( Scripting::GetEnumeration< SizeScalePolicy::Type >( property.Get< std::string >().c_str(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount ) );
        break;
      }
  
@@@ -2858,7 -2884,7 +2885,7 @@@
      {
        if( property.Get< bool >() )
        {
-         SetResizePolicy( DIMENSION_DEPENDENCY, WIDTH );
+         SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
        }
        break;
      }
@@@ -2867,7 -2893,7 +2894,7 @@@
      {
        if( property.Get< bool >() )
        {
-         SetResizePolicy( DIMENSION_DEPENDENCY, HEIGHT );
+         SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
        }
        break;
      }
@@@ -2875,24 -2901,24 +2902,24 @@@
      case Dali::Actor::Property::PADDING:
      {
        Vector4 padding = property.Get< Vector4 >();
-       SetPadding( Vector2( padding.x, padding.y ), WIDTH );
-       SetPadding( Vector2( padding.z, padding.w ), HEIGHT );
+       SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
+       SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
        break;
      }
  
      case Dali::Actor::Property::MINIMUM_SIZE:
      {
        Vector2 size = property.Get< Vector2 >();
-       SetMinimumSize( size.x, WIDTH );
-       SetMinimumSize( size.y, HEIGHT );
+       SetMinimumSize( size.x, Dimension::WIDTH );
+       SetMinimumSize( size.y, Dimension::HEIGHT );
        break;
      }
  
      case Dali::Actor::Property::MAXIMUM_SIZE:
      {
        Vector2 size = property.Get< Vector2 >();
-       SetMaximumSize( size.x, WIDTH );
-       SetMaximumSize( size.y, HEIGHT );
+       SetMaximumSize( size.x, Dimension::WIDTH );
+       SetMaximumSize( size.y, Dimension::HEIGHT );
        break;
      }
  
@@@ -3296,51 -3322,51 +3323,51 @@@ Property::Value Actor::GetDefaultProper
  
      case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
      {
-       value = Scripting::GetLinearEnumerationName< ResizePolicy >( GetResizePolicy( WIDTH ), ResizePolicyTable, ResizePolicyTableCount );
+       value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
        break;
      }
  
      case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
      {
-       value = Scripting::GetLinearEnumerationName< ResizePolicy >( GetResizePolicy( HEIGHT ), ResizePolicyTable, ResizePolicyTableCount );
+       value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), ResizePolicy::TypeTable, ResizePolicy::TypeTableCount );
        break;
      }
  
      case Dali::Actor::Property::SIZE_SCALE_POLICY:
      {
-       value = Scripting::GetLinearEnumerationName< SizeScalePolicy >( GetSizeScalePolicy(), SizeScalePolicyTable, SizeScalePolicyTableCount );
+       value = Scripting::GetLinearEnumerationName< SizeScalePolicy::Type >( GetSizeScalePolicy(), SizeScalePolicy::TypeTable, SizeScalePolicy::TypeTableCount );
        break;
      }
  
      case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
      {
-       value = ( GetResizePolicy( WIDTH ) == DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( WIDTH ) == HEIGHT );
+       value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
        break;
      }
  
      case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
      {
-       value = ( GetResizePolicy( HEIGHT ) == DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( HEIGHT ) == WIDTH );
+       value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
        break;
      }
  
      case Dali::Actor::Property::PADDING:
      {
-       Vector2 widthPadding = GetPadding( WIDTH );
-       Vector2 heightPadding = GetPadding( HEIGHT );
+       Vector2 widthPadding = GetPadding( Dimension::WIDTH );
+       Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
        value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
        break;
      }
  
      case Dali::Actor::Property::MINIMUM_SIZE:
      {
-       value = Vector2( GetMinimumSize( WIDTH ), GetMinimumSize( HEIGHT ) );
+       value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
        break;
      }
  
      case Dali::Actor::Property::MAXIMUM_SIZE:
      {
-       value = Vector2( GetMaximumSize( WIDTH ), GetMaximumSize( HEIGHT ) );
+       value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
        break;
      }
  
@@@ -3808,15 -3834,15 +3835,15 @@@ void Actor::EnsureRelayoutData() cons
    }
  }
  
- bool Actor::RelayoutDependentOnParent( Dimension dimension )
+ bool Actor::RelayoutDependentOnParent( Dimension::Type dimension )
  {
    // Check if actor is dependent on parent
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) )
      {
-       const ResizePolicy resizePolicy = GetResizePolicy( static_cast< Dimension >( 1 << i ) );
-       if( resizePolicy == FILL_TO_PARENT || resizePolicy == SIZE_RELATIVE_TO_PARENT || resizePolicy == SIZE_FIXED_OFFSET_FROM_PARENT )
+       const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
+       if( resizePolicy == ResizePolicy::FILL_TO_PARENT || resizePolicy == ResizePolicy::SIZE_RELATIVE_TO_PARENT || resizePolicy == ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT )
        {
          return true;
        }
@@@ -3826,18 -3852,18 +3853,18 @@@
    return false;
  }
  
- bool Actor::RelayoutDependentOnChildren( Dimension dimension )
+ bool Actor::RelayoutDependentOnChildren( Dimension::Type dimension )
  {
    // Check if actor is dependent on children
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) )
      {
-       const ResizePolicy resizePolicy = GetResizePolicy( static_cast< Dimension >( 1 << i ) );
+       const ResizePolicy::Type resizePolicy = GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) );
        switch( resizePolicy )
        {
-         case FIT_TO_CHILDREN:
-         case USE_NATURAL_SIZE:      // i.e. For things that calculate their size based on children
+         case ResizePolicy::FIT_TO_CHILDREN:
+         case ResizePolicy::USE_NATURAL_SIZE:      // i.e. For things that calculate their size based on children
          {
            return true;
          }
@@@ -3853,28 -3879,28 +3880,28 @@@
    return false;
  }
  
- bool Actor::RelayoutDependentOnChildrenBase( Dimension dimension )
+ bool Actor::RelayoutDependentOnChildrenBase( Dimension::Type dimension )
  {
    return Actor::RelayoutDependentOnChildren( dimension );
  }
  
- bool Actor::RelayoutDependentOnDimension( Dimension dimension, Dimension dependentDimension )
+ bool Actor::RelayoutDependentOnDimension( Dimension::Type dimension, Dimension::Type dependentDimension )
  {
    // Check each possible dimension and see if it is dependent on the input one
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
-       return mRelayoutData->resizePolicies[ i ] == DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
+       return mRelayoutData->resizePolicies[ i ] == ResizePolicy::DIMENSION_DEPENDENCY && mRelayoutData->dimensionDependencies[ i ] == dependentDimension;
      }
    }
  
    return false;
  }
  
- void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension dimension )
+ void Actor::SetNegotiatedDimension( float negotiatedDimension, Dimension::Type dimension )
  {
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -3883,10 -3909,10 +3910,10 @@@
    }
  }
  
- float Actor::GetNegotiatedDimension( Dimension dimension ) const
+ float Actor::GetNegotiatedDimension( Dimension::Type dimension ) const
  {
    // If more than one dimension is requested, just return the first one found
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) )
      {
@@@ -3897,11 -3923,11 +3924,11 @@@
    return 0.0f;   // Default
  }
  
- void Actor::SetPadding( const Vector2& padding, Dimension dimension )
+ void Actor::SetPadding( const Vector2& padding, Dimension::Type dimension )
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -3910,12 -3936,12 +3937,12 @@@
    }
  }
  
- Vector2 Actor::GetPadding( Dimension dimension ) const
+ Vector2 Actor::GetPadding( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
    // If more than one dimension is requested, just return the first one found
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) )
      {
@@@ -3926,9 -3952,9 +3953,9 @@@
    return Vector2( 0.0f, 0.0f );   // Default
  }
  
- void Actor::SetLayoutNegotiated( bool negotiated, Dimension dimension )
+ void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
  {
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -3937,9 -3963,9 +3964,9 @@@
    }
  }
  
- bool Actor::IsLayoutNegotiated( Dimension dimension ) const
+ bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
  {
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
      {
@@@ -3950,28 -3976,28 +3977,28 @@@
    return false;
  }
  
- float Actor::CalculateChildSize( const Dali::Actor& child, Dimension dimension )
+ float Actor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
  {
    // Could be overridden in derived classes.
    return CalculateChildSizeBase( child, dimension );
  }
  
- float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension dimension )
+ float Actor::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
  {
    // Fill to parent, taking size mode factor into account
    switch( child.GetResizePolicy( dimension ) )
    {
-     case FILL_TO_PARENT:
+     case ResizePolicy::FILL_TO_PARENT:
      {
        return GetLatestSize( dimension );
      }
  
-     case SIZE_RELATIVE_TO_PARENT:
+     case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
      {
        return GetLatestSize( dimension ) * GetDimensionValue( child.GetSizeModeFactor(), dimension );
      }
  
-     case SIZE_FIXED_OFFSET_FROM_PARENT:
+     case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
      {
        return GetLatestSize( dimension ) + GetDimensionValue( child.GetSizeModeFactor(), dimension );
      }
@@@ -4011,19 -4037,19 +4038,19 @@@ float Actor::GetWidthForHeight( float h
    return width;
  }
  
- float Actor::GetLatestSize( Dimension dimension ) const
+ float Actor::GetLatestSize( Dimension::Type dimension ) const
  {
    return IsLayoutNegotiated( dimension ) ? GetNegotiatedDimension( dimension ) : GetSize( dimension );
  }
  
- float Actor::GetRelayoutSize( Dimension dimension ) const
+ float Actor::GetRelayoutSize( Dimension::Type dimension ) const
  {
    Vector2 padding = GetPadding( dimension );
  
    return GetLatestSize( dimension ) + padding.x + padding.y;
  }
  
- float Actor::NegotiateFromParent( Dimension dimension )
+ float Actor::NegotiateFromParent( Dimension::Type dimension )
  {
    Actor* parent = GetParent();
    if( parent )
@@@ -4036,9 -4062,8 +4063,8 @@@
    return 0.0f;
  }
  
- float Actor::NegotiateFromChildren( Dimension dimension )
+ float Actor::NegotiateFromChildren( Dimension::Type dimension )
  {
-   float minDimensionPoint = 0.0f;
    float maxDimensionPoint = 0.0f;
  
    for( unsigned int i = 0, count = GetChildCount(); i < count; ++i )
@@@ -4049,70 -4074,69 +4075,69 @@@
      if( !childImpl.RelayoutDependentOnParent( dimension ) )
      {
        // Calculate the min and max points that the children range across
-       float childPosition = GetDimensionValue( childImpl.GetCurrentPosition(), dimension );
+       float childPosition = GetDimensionValue( childImpl.GetTargetPosition(), dimension );
        float dimensionSize = childImpl.GetRelayoutSize( dimension );
-       minDimensionPoint = std::min( minDimensionPoint, childPosition - dimensionSize * 0.5f );
-       maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize * 0.5f );
+       maxDimensionPoint = std::max( maxDimensionPoint, childPosition + dimensionSize );
      }
    }
  
-   return maxDimensionPoint - minDimensionPoint;
+   return maxDimensionPoint;
  }
  
- float Actor::GetSize( Dimension dimension ) const
+ float Actor::GetSize( Dimension::Type dimension ) const
  {
    return GetDimensionValue( GetTargetSize(), dimension );
  }
  
- float Actor::GetNaturalSize( Dimension dimension ) const
+ float Actor::GetNaturalSize( Dimension::Type dimension ) const
  {
    return GetDimensionValue( GetNaturalSize(), dimension );
  }
  
- float Actor::CalculateSize( Dimension dimension, const Vector2& maximumSize )
+ float Actor::CalculateSize( Dimension::Type dimension, const Vector2& maximumSize )
  {
    switch( GetResizePolicy( dimension ) )
    {
-     case USE_NATURAL_SIZE:
+     case ResizePolicy::USE_NATURAL_SIZE:
      {
        return GetNaturalSize( dimension );
      }
  
-     case FIXED:
+     case ResizePolicy::FIXED:
      {
        return GetDimensionValue( GetPreferredSize(), dimension );
      }
  
-     case USE_ASSIGNED_SIZE:
+     case ResizePolicy::USE_ASSIGNED_SIZE:
      {
        return GetDimensionValue( maximumSize, dimension );
      }
  
-     case FILL_TO_PARENT:
-     case SIZE_RELATIVE_TO_PARENT:
-     case SIZE_FIXED_OFFSET_FROM_PARENT:
+     case ResizePolicy::FILL_TO_PARENT:
+     case ResizePolicy::SIZE_RELATIVE_TO_PARENT:
+     case ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT:
      {
        return NegotiateFromParent( dimension );
      }
  
-     case FIT_TO_CHILDREN:
+     case ResizePolicy::FIT_TO_CHILDREN:
      {
        return NegotiateFromChildren( dimension );
      }
  
-     case DIMENSION_DEPENDENCY:
+     case ResizePolicy::DIMENSION_DEPENDENCY:
      {
-       const Dimension dimensionDependency = GetDimensionDependency( dimension );
+       const Dimension::Type dimensionDependency = GetDimensionDependency( dimension );
  
        // Custom rules
-       if( dimension == WIDTH && dimensionDependency == HEIGHT )
+       if( dimension == Dimension::WIDTH && dimensionDependency == Dimension::HEIGHT )
        {
-         return GetWidthForHeight( GetNegotiatedDimension( HEIGHT ) );
+         return GetWidthForHeight( GetNegotiatedDimension( Dimension::HEIGHT ) );
        }
  
-       if( dimension == HEIGHT && dimensionDependency == WIDTH )
+       if( dimension == Dimension::HEIGHT && dimensionDependency == Dimension::WIDTH )
        {
-         return GetHeightForWidth( GetNegotiatedDimension( WIDTH ) );
+         return GetHeightForWidth( GetNegotiatedDimension( Dimension::WIDTH ) );
        }
  
        break;
@@@ -4127,7 -4151,7 +4152,7 @@@
    return 0.0f;  // Default
  }
  
- float Actor::ConstrainDimension( float size, Dimension dimension )
+ float Actor::ConstrainDimension( float size, Dimension::Type dimension )
  {
    const float minSize = GetMinimumSize( dimension );
    const float maxSize = GetMaximumSize( dimension );
@@@ -4135,7 -4159,7 +4160,7 @@@
    return std::max( minSize, std::min( size, maxSize ) );
  }
  
- void Actor::NegotiateDimension( Dimension dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
+ void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
  {
    // Check if it needs to be negotiated
    if( IsLayoutDirty( dimension ) && !IsLayoutNegotiated( dimension ) )
@@@ -4158,9 -4182,9 +4183,9 @@@
        recursionStack.push_back( ActorDimensionPair( this, dimension ) );
  
        // Dimension dependency check
-       for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+       for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
        {
-         Dimension dimensionToCheck = static_cast< Dimension >( 1 << i );
+         Dimension::Type dimensionToCheck = static_cast< Dimension::Type >( 1 << i );
  
          if( RelayoutDependentOnDimension( dimension, dimensionToCheck ) )
          {
@@@ -4219,9 -4243,9 +4244,9 @@@ void Actor::NegotiateDimensions( const 
    // Negotiate all dimensions that require it
    ActorDimensionStack recursionStack;
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
-     const Dimension dimension = static_cast< Dimension >( 1 << i );
+     const Dimension::Type dimension = static_cast< Dimension::Type >( 1 << i );
  
      // Negotiate
      NegotiateDimension( dimension, allocatedSize, recursionStack );
@@@ -4232,12 -4256,12 +4257,12 @@@ Vector2 Actor::ApplySizeSetPolicy( cons
  {
    switch( mRelayoutData->sizeSetPolicy )
    {
-     case USE_SIZE_SET:
+     case SizeScalePolicy::USE_SIZE_SET:
      {
        return size;
      }
  
-     case FIT_WITH_ASPECT_RATIO:
+     case SizeScalePolicy::FIT_WITH_ASPECT_RATIO:
      {
        // Scale size to fit within the original size bounds, keeping the natural size aspect ratio
        const Vector3 naturalSize = GetNaturalSize();
@@@ -4263,7 -4287,7 +4288,7 @@@
        break;
      }
  
-     case FILL_WITH_ASPECT_RATIO:
+     case SizeScalePolicy::FILL_WITH_ASPECT_RATIO:
      {
        // Scale size to fill the original size bounds, keeping the natural size aspect ratio. Potentially exceeding the original bounds.
        const Vector3 naturalSize = GetNaturalSize();
@@@ -4299,7 -4323,7 +4324,7 @@@
  void Actor::SetNegotiatedSize( RelayoutContainer& container )
  {
    // Do the set actor size
-   Vector2 negotiatedSize( GetLatestSize( WIDTH ), GetLatestSize( HEIGHT ) );
+   Vector2 negotiatedSize( GetLatestSize( Dimension::WIDTH ), GetLatestSize( Dimension::HEIGHT ) );
  
    // Adjust for size set policy
    negotiatedSize = ApplySizeSetPolicy( negotiatedSize );
@@@ -4345,7 -4369,7 +4370,7 @@@ void Actor::NegotiateSize( const Vector
    }
  }
  
- void Actor::RelayoutRequest( Dimension dimension )
+ void Actor::RelayoutRequest( Dimension::Type dimension )
  {
    Internal::RelayoutController* relayoutController = Internal::RelayoutController::Get();
    if( relayoutController )
@@@ -4375,11 -4399,11 +4400,11 @@@ void Actor::PropagateRelayoutFlags(
    }
  }
  
- void Actor::OnCalculateRelayoutSize( Dimension dimension )
+ void Actor::OnCalculateRelayoutSize( Dimension::Type dimension )
  {
  }
  
- void Actor::OnLayoutNegotiated( float size, Dimension dimension )
+ void Actor::OnLayoutNegotiated( float size, Dimension::Type dimension )
  {
  }
  
@@@ -4389,12 -4413,12 +4414,12 @@@ void Actor::SetPreferredSize( const Vec
  
    if( size.width > 0.0f )
    {
-     SetResizePolicy( FIXED, WIDTH );
+     SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
    }
  
    if( size.height > 0.0f )
    {
-     SetResizePolicy( FIXED, HEIGHT );
+     SetResizePolicy( ResizePolicy::FIXED, Dimension::HEIGHT );
    }
  
    mRelayoutData->preferredSize = size;
@@@ -4409,11 -4433,11 +4434,11 @@@ Vector2 Actor::GetPreferredSize() cons
    return mRelayoutData->preferredSize;
  }
  
- void Actor::SetMinimumSize( float size, Dimension dimension )
+ void Actor::SetMinimumSize( float size, Dimension::Type dimension )
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -4424,11 -4448,11 +4449,11 @@@
    RelayoutRequest();
  }
  
- float Actor::GetMinimumSize( Dimension dimension ) const
+ float Actor::GetMinimumSize( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -4439,11 -4463,11 +4464,11 @@@
    return 0.0f;  // Default
  }
  
- void Actor::SetMaximumSize( float size, Dimension dimension )
+ void Actor::SetMaximumSize( float size, Dimension::Type dimension )
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {
@@@ -4454,11 -4478,11 +4479,11 @@@
    RelayoutRequest();
  }
  
- float Actor::GetMaximumSize( Dimension dimension ) const
+ float Actor::GetMaximumSize( Dimension::Type dimension ) const
  {
    EnsureRelayoutData();
  
-   for( unsigned int i = 0; i < DIMENSION_COUNT; ++i )
+   for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i )
    {
      if( dimension & ( 1 << i ) )
      {

diff --combined dali/internal/event/actors/image-actor-impl.cpp
index d55d0c6,935614e..9768ed8
--- 1/dali/internal/event/actors/image-actor-impl.cpp
--- 2/dali/internal/event/actors/image-actor-impl.cpp
+++ b/dali/internal/event/actors/image-actor-impl.cpp
@@@ -18,9 -18,6 +18,9 @@@
  // CLASS HEADER
  #include <dali/internal/event/actors/image-actor-impl.h>
  
 +// EXTERNAL INCLUDES
 +#include <cstring> // for strcmp
 +
  // INTERNAL INCLUDES
  #include <dali/public-api/object/type-registry.h>
  #include <dali/public-api/scripting/scripting.h>
@@@ -103,7 -100,7 +103,7 @@@ ImageActorPtr ImageActor::New(
  
  void ImageActor::OnInitialize()
  {
-   SetResizePolicy( USE_NATURAL_SIZE, ALL_DIMENSIONS );
+   SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
  }
  
  void ImageActor::SetImage( ImagePtr& image )