X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Falignment%2Falignment-impl.cpp;h=97135879c9451d8eaa599032d2f03c15f1ac48e3;hb=afb47f411d700d2b4be6415b61995cde5c37126c;hp=fa0999193713e340b406083bececc3c85c7c1ddc;hpb=e2eda444afbe82e9591fe198eef339227f90a616;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/dali-toolkit/internal/controls/alignment/alignment-impl.cpp b/dali-toolkit/internal/controls/alignment/alignment-impl.cpp
index fa09991..9713587 100644
--- a/dali-toolkit/internal/controls/alignment/alignment-impl.cpp
+++ b/dali-toolkit/internal/controls/alignment/alignment-impl.cpp
@@ -1,26 +1,28 @@
-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
 
 // CLASS HEADER
-
 #include "alignment-impl.h"
 
-// INTERNAL INCLUDES
-
 // EXTERNAL INCLUDES
+#include <dali/public-api/object/property-input.h>
+#include <dali/public-api/object/type-registry.h>
+#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/size-negotiation/relayout-container.h>
 
 namespace Dali
 {
@@ -40,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
 {
@@ -52,14 +55,6 @@ struct ScaleToFillConstraint
   {}
 
   /**
-   * CopyConstructor. Used by Boost.
-   * @param rhs Copying from.
-   */
-  ScaleToFillConstraint( const ScaleToFillConstraint& rhs )
-  : mPadding( rhs.mPadding )
-  {}
-
-  /**
    * Called by render thread
    */
   Vector3 operator()( const Vector3& currentSize,
@@ -98,16 +93,6 @@ struct ScaleToFitKeepAspectConstraint
   {}
 
   /**
-   * CopyConstructor. Used by Boost.
-   * @param rhs Copying from.
-   */
-  ScaleToFitKeepAspectConstraint( const ScaleToFitKeepAspectConstraint& rhs )
-  : mPadding( rhs.mPadding ),
-    mSizeStored( rhs.mSizeStored ),
-    mOriginalSize( rhs.mOriginalSize )
-  {}
-
-  /**
    * Called by render thread
    */
   Vector3 operator()( const Vector3& currentSize,
@@ -156,16 +141,6 @@ struct ScaleToFillKeepAspectConstraint
   { }
 
   /**
-   * CopyConstructor. Used by Boost.
-   * @param rhs Copying from.
-   */
-  ScaleToFillKeepAspectConstraint( const ScaleToFillKeepAspectConstraint& rhs )
-  : mPadding( rhs.mPadding ),
-    mSizeStored( rhs.mSizeStored ),
-    mOriginalSize( rhs.mOriginalSize )
-  {}
-
-  /**
    * Called by render thread
    */
   Vector3 operator()( const Vector3& currentSize,
@@ -214,16 +189,6 @@ struct ShrinkToFitConstraint
   {}
 
   /**
-   * CopyConstructor. Used by Boost.
-   * @param rhs Copying from.
-   */
-  ShrinkToFitConstraint( const ShrinkToFitConstraint& rhs )
-  : mPadding( rhs.mPadding ),
-    mSizeStored( rhs.mSizeStored ),
-    mOriginalSize( rhs.mOriginalSize )
-  { }
-
-  /**
    * Called by render thread
    */
   Vector3 operator()( const Vector3& currentSize,
@@ -275,16 +240,6 @@ struct ShrinkToFitKeepAspectConstraint
   {}
 
   /**
-   * CopyConstructor. Used by Boost.
-   * @param rhs Copying from.
-   */
-  ShrinkToFitKeepAspectConstraint( const ShrinkToFitKeepAspectConstraint& rhs )
-  : mPadding( rhs.mPadding ),
-    mSizeStored( rhs.mSizeStored ),
-    mOriginalSize( rhs.mOriginalSize )
-  { }
-
-  /**
    * Called by render thread
    */
   Vector3 operator()( const Vector3& currentSize,
@@ -338,16 +293,6 @@ struct PositionConstraint
   {}
 
   /**
-   * CopyConstructor. Used by Boost.
-   * @param rhs Copying from.
-   */
-  PositionConstraint( const PositionConstraint& rhs )
-  : mPadding( rhs.mPadding ),
-    mHorizontalAlignment( rhs.mHorizontalAlignment ),
-    mVerticalAlignment( rhs.mVerticalAlignment )
-  {}
-
-  /**
    * Called by render thread.
    */
   Vector3 operator()( const Vector3& currentPosition,
@@ -357,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;
@@ -420,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 )
@@ -449,43 +390,31 @@ Toolkit::Alignment Alignment::New( Toolkit::Alignment::Type horizontal, Toolkit:
 void Alignment::SetAlignmentType( Toolkit::Alignment::Type type )
 {
   // Horizontal Alignment
-  bool horizontalSet(false);
-
+  if( type & Toolkit::Alignment::HorizontalRight )
+  {
+    mHorizontal = Toolkit::Alignment::HorizontalRight;
+  }
   if( type & Toolkit::Alignment::HorizontalLeft )
   {
     mHorizontal = Toolkit::Alignment::HorizontalLeft;
-    horizontalSet = true;
   }
   if( type & Toolkit::Alignment::HorizontalCenter )
   {
-    DALI_ASSERT_ALWAYS(!horizontalSet);
     mHorizontal = Toolkit::Alignment::HorizontalCenter;
-    horizontalSet = true;
-  }
-  if( type & Toolkit::Alignment::HorizontalRight )
-  {
-    DALI_ASSERT_ALWAYS(!horizontalSet);
-    mHorizontal = Toolkit::Alignment::HorizontalRight;
   }
 
   // Vertical Alignment
-  bool verticalSet(false);
-
+  if( type & Toolkit::Alignment::VerticalBottom )
+  {
+    mVertical = Toolkit::Alignment::VerticalBottom;
+  }
   if( type & Toolkit::Alignment::VerticalTop )
   {
     mVertical = Toolkit::Alignment::VerticalTop;
-    verticalSet = true;
   }
   if( type & Toolkit::Alignment::VerticalCenter )
   {
-    DALI_ASSERT_ALWAYS(!verticalSet);
     mVertical = Toolkit::Alignment::VerticalCenter;
-    verticalSet = true;
-  }
-  if( type & Toolkit::Alignment::VerticalBottom )
-  {
-    DALI_ASSERT_ALWAYS(!verticalSet);
-    mVertical = Toolkit::Alignment::VerticalBottom;
   }
 
   RelayoutRequest();
@@ -522,7 +451,7 @@ const Toolkit::Alignment::Padding& Alignment::GetPadding() const
   return mPadding;
 }
 
-void Alignment::OnRelaidOut( Vector2 size, ActorSizeContainer& container )
+void Alignment::OnRelayout( const Vector2& size, RelayoutContainer& container )
 {
   // lay out the actors
   Vector3 anchorPointAndParentOrigin  = Vector3::ZERO;
@@ -546,69 +475,59 @@ void Alignment::OnRelaidOut( 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() );
-    Control control( 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:
@@ -618,12 +537,18 @@ void Alignment::OnRelaidOut( 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 )
-: ControlImpl( false ),  // doesn't require touch events
+: Control( CONTROL_BEHAVIOUR_NONE ),
   mHorizontal( horizontal ),
   mVertical( vertical ),
   mScaling( Toolkit::Alignment::ScaleNone ),