Merge "Delete view from toolkit and move cluster into demo" into tizen

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / alignment / alignment-impl.cpp

diff --git a/dali-toolkit/internal/controls/alignment/alignment-impl.cpp b/dali-toolkit/internal/controls/alignment/alignment-impl.cpp
index e887cb4..b06e57b 100644 (file)
--- a/dali-toolkit/internal/controls/alignment/alignment-impl.cpp
+++ b/dali-toolkit/internal/controls/alignment/alignment-impl.cpp
@@ -16,13 +16,13 @@
  */
 
 // CLASS HEADER
-
 #include "alignment-impl.h"
 
 // EXTERNAL INCLUDES
+#include <dali/public-api/object/property-input.h>
 #include <dali/public-api/object/type-registry.h>
-
-// INTERNAL INCLUDES
+#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/size-negotiation/relayout-container.h>
 
 namespace Dali
 {
@@ -42,7 +42,8 @@ BaseHandle Create()
   return Toolkit::Alignment::New();
 }
 
-TypeRegistration mType( typeid(Toolkit::Alignment), typeid(Toolkit::Control), Create );
+DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Alignment, Toolkit::Control, Create )
+DALI_TYPE_REGISTRATION_END()
 
 struct ScaleToFillConstraint
 {
@@ -301,60 +302,65 @@ struct PositionConstraint
     const Vector3& currentSize( currentSizeProperty.GetVector3() );
     const Vector3& parentSize( parentSizeProperty.GetVector3() );
 
+    return GetPosition( currentSize, parentSize );
+  }
+
+  inline Vector3 GetPosition( const Vector3& currentSize, const Vector3& parentSize )
+  {
     Vector3 position( 0.f, 0.f, 0.f );
 
     switch( mHorizontalAlignment )
     {
-      case Dali::Toolkit::Alignment::HorizontalLeft:
-      {
-        position.x += mPadding.left;
-        break;
-      }
-      case Dali::Toolkit::Alignment::HorizontalCenter:
-      {
-        if( currentSize.width + mPadding.left + mPadding.right >= parentSize.width )
-        {
-          position.x += 0.5f * ( mPadding.left - mPadding.right );
-        }
-        break;
-      }
-      case Dali::Toolkit::Alignment::HorizontalRight:
-      {
-        position.x -= mPadding.right;
-        break;
-      }
-      default:
+    case Dali::Toolkit::Alignment::HorizontalLeft:
+    {
+      position.x += mPadding.left;
+      break;
+    }
+    case Dali::Toolkit::Alignment::HorizontalCenter:
+    {
+      if( currentSize.width + mPadding.left + mPadding.right >= parentSize.width )
       {
-        DALI_ASSERT_ALWAYS( !"Wrong horizontal alignment value" );
-        break;
+        position.x += 0.5f * ( mPadding.left - mPadding.right );
       }
+      break;
+    }
+    case Dali::Toolkit::Alignment::HorizontalRight:
+    {
+      position.x -= mPadding.right;
+      break;
+    }
+    default:
+    {
+      DALI_ASSERT_ALWAYS( !"Wrong horizontal alignment value" );
+      break;
+    }
     }
 
     switch( mVerticalAlignment )
     {
-      case Dali::Toolkit::Alignment::VerticalTop:
-      {
-        position.y += mPadding.top;
-        break;
-      }
-      case Dali::Toolkit::Alignment::VerticalCenter:
-      {
-        if( currentSize.height + mPadding.top + mPadding.bottom >= parentSize.height )
-        {
-          position.y += 0.5f * ( mPadding.top - mPadding.bottom );
-        }
-        break;
-      }
-      case Dali::Toolkit::Alignment::VerticalBottom:
-      {
-        position.y -= mPadding.bottom;
-        break;
-      }
-      default:
+    case Dali::Toolkit::Alignment::VerticalTop:
+    {
+      position.y += mPadding.top;
+      break;
+    }
+    case Dali::Toolkit::Alignment::VerticalCenter:
+    {
+      if( currentSize.height + mPadding.top + mPadding.bottom >= parentSize.height )
       {
-        DALI_ASSERT_ALWAYS( !"Wrong vertical alignment value" );
-        break;
+        position.y += 0.5f * ( mPadding.top - mPadding.bottom );
       }
+      break;
+    }
+    case Dali::Toolkit::Alignment::VerticalBottom:
+    {
+      position.y -= mPadding.bottom;
+      break;
+    }
+    default:
+    {
+      DALI_ASSERT_ALWAYS( !"Wrong vertical alignment value" );
+      break;
+    }
     }
 
     return position;
@@ -364,15 +370,6 @@ struct PositionConstraint
   const Toolkit::Alignment::Type mHorizontalAlignment;
   const Toolkit::Alignment::Type mVerticalAlignment;
 };
-
-void SetPositionConstraint( Actor actor, const Toolkit::Alignment::Padding& padding, Toolkit::Alignment::Type horizontal, Toolkit::Alignment::Type vertical )
-{
-  Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
-                                                    LocalSource( Actor::SIZE ),
-                                                    ParentSource( Actor::SIZE ),
-                                                    PositionConstraint( padding, horizontal, vertical ) );
-  actor.ApplyConstraint( constraint );
-}
 } // namespace
 
 Toolkit::Alignment Alignment::New( Toolkit::Alignment::Type horizontal, Toolkit::Alignment::Type vertical )
@@ -380,7 +377,7 @@ Toolkit::Alignment Alignment::New( Toolkit::Alignment::Type horizontal, Toolkit:
   // Create the implementation, temporarily owned on stack
   IntrusivePtr< Alignment > internalAlignment = new Alignment( horizontal, vertical );
 
-  // Pass ownership to Toolkit::View
+  // Pass ownership to Toolkit::Alignment
   Toolkit::Alignment alignment( *internalAlignment );
 
   // Second-phase init of the implementation
@@ -454,7 +451,7 @@ const Toolkit::Alignment::Padding& Alignment::GetPadding() const
   return mPadding;
 }
 
-void Alignment::OnRelayout( const Vector2& size, ActorSizeContainer& container )
+void Alignment::OnRelayout( const Vector2& size, RelayoutContainer& container )
 {
   // lay out the actors
   Vector3 anchorPointAndParentOrigin  = Vector3::ZERO;
@@ -478,69 +475,59 @@ void Alignment::OnRelayout( const Vector2& size, ActorSizeContainer& container )
     anchorPointAndParentOrigin.y = 1.0f;
   }
 
-  unsigned int childCount = Self().GetChildCount();
-  for( unsigned int i=0; i<childCount; ++i )
+  for( unsigned int i = 0, childCount = Self().GetChildCount(); i < childCount; ++i )
   {
-    Actor actor = Self().GetChildAt(i);
+    Actor child = Self().GetChildAt(i);
 
-    actor.SetAnchorPoint( anchorPointAndParentOrigin );
-    actor.SetParentOrigin( anchorPointAndParentOrigin );
+    child.SetAnchorPoint( anchorPointAndParentOrigin );
+    child.SetParentOrigin( anchorPointAndParentOrigin );
 
-    if( Toolkit::Alignment::ScaleNone != mScaling )
+    Vector3 currentChildSize( child.GetTargetSize() );
+    if( currentChildSize == Vector3::ZERO )
     {
-      actor.RemoveConstraints();
+      currentChildSize = child.GetNaturalSize();
     }
 
-    Vector3 actorSize ( actor.GetCurrentSize() );
-    Toolkit::Control control( Toolkit::Control::DownCast( actor ) );
-    if ( actorSize == Vector3::ZERO && control )
-    {
-      actorSize = control.GetNaturalSize();
-    }
-
-    Vector2 childSize;
+    bool renegotiate = true;
+    Vector3 newChildSize;
 
     switch( mScaling )
     {
       case Toolkit::Alignment::ScaleNone:
       {
         // Nothing to do but needed just to not to jump to the default.
-        childSize = size;
+        newChildSize = currentChildSize;
+        renegotiate = false;
         break;
       }
       case Toolkit::Alignment::ScaleToFill:
       {
         ScaleToFillConstraint constraint( mPadding );
-        childSize = Vector2( constraint.GetSize( actorSize, Vector3(size) ) );
-        SetPositionConstraint( actor, mPadding, mHorizontal, mVertical );
+        newChildSize = constraint.GetSize( currentChildSize, Vector3(size) ) ;
         break;
       }
       case Toolkit::Alignment::ScaleToFitKeepAspect:
       {
         ScaleToFitKeepAspectConstraint constraint( mPadding );
-        childSize = Vector2( constraint.GetSize( actorSize, Vector3(size) ) );
-        SetPositionConstraint( actor, mPadding, mHorizontal, mVertical );
+        newChildSize = constraint.GetSize( currentChildSize, Vector3(size) ) ;
         break;
       }
       case Toolkit::Alignment::ScaleToFillKeepAspect:
       {
         ScaleToFillKeepAspectConstraint constraint( mPadding );
-        childSize = Vector2( constraint.GetSize( actorSize, Vector3(size) ) );
-        SetPositionConstraint( actor, mPadding, mHorizontal, mVertical );
+        newChildSize = constraint.GetSize( currentChildSize, Vector3(size) );
         break;
       }
       case Toolkit::Alignment::ShrinkToFit:
       {
         ShrinkToFitConstraint constraint( mPadding );
-        childSize = Vector2( constraint.GetSize( actorSize, Vector3(size) ) );
-        SetPositionConstraint( actor, mPadding, mHorizontal, mVertical );
+        newChildSize = constraint.GetSize( currentChildSize, Vector3(size) );
         break;
       }
       case Toolkit::Alignment::ShrinkToFitKeepAspect:
       {
         ShrinkToFitKeepAspectConstraint constraint( mPadding );
-        childSize = Vector2( constraint.GetSize( actorSize, Vector3(size) ) );
-        SetPositionConstraint( actor, mPadding, mHorizontal, mVertical );
+        newChildSize = constraint.GetSize( currentChildSize, Vector3(size) );
         break;
       }
       default:
@@ -550,12 +537,18 @@ void Alignment::OnRelayout( const Vector2& size, ActorSizeContainer& container )
       }
     }
 
-    Relayout( actor, childSize, container );
+    PositionConstraint positionConstraint(mPadding, mHorizontal, mVertical);
+    child.SetPosition( positionConstraint.GetPosition(newChildSize, currentChildSize) );
+
+    if( renegotiate )
+    {
+      container.Add( child, Vector2(newChildSize) );
+    }
   }
 }
 
 Alignment::Alignment( Toolkit::Alignment::Type horizontal, Toolkit::Alignment::Type vertical )
-: Control( CONTROL_BEHAVIOUR_NONE ),
+: Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ),
   mHorizontal( horizontal ),
   mVertical( vertical ),
   mScaling( Toolkit::Alignment::ScaleNone ),