X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Fpublic-api%2Fcontrols%2Fscrollable%2Fitem-view%2Fitem-layout.cpp;h=7d6d17fa9bcfa3c3fd0ea4914daebf740e28f127;hp=33acbc43bc0dd968d06d0f1692f386408f636f1c;hb=df92f45e89c92ca9b2286d51116ff7b69e75c569;hpb=928136dbb9e23970f3894eabc7c8b224003b77be

diff --git a/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp b/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp
index 33acbc4..7d6d17f 100644
--- a/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp
+++ b/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 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.
@@ -19,7 +19,7 @@
 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
 
 // EXTERNAL INCLUDES
-#include <dali/public-api/animation/active-constraint.h>
+#include <dali/public-api/animation/animation.h>
 #include <dali/public-api/animation/constraint.h>
 #include <dali/public-api/animation/time-period.h>
 
@@ -29,82 +29,96 @@
 namespace
 {
 
-  // Functors which wrap constraint functions with stored item IDs
-  struct WrappedQuaternionConstraint
+// Lerps between current and target using the progress
+template< typename Type >
+void Lerp( Type& current, const Type& target, float progress )
+{
+  current += ((target - current) * progress);
+}
+
+// Functors which wrap constraint functions with stored item IDs
+struct WrappedQuaternionConstraint
+{
+  WrappedQuaternionConstraint( Dali::Toolkit::ItemLayout::QuaternionFunction wrapMe, unsigned int itemId )
+  :mWrapMe(wrapMe),
+   mItemId(itemId)
   {
-    WrappedQuaternionConstraint(Dali::Toolkit::ItemLayout::QuaternionFunction wrapMe, unsigned int itemId)
-    :mWrapMe(wrapMe),
-     mItemId(itemId)
-    {
-    }
+  }
 
-    Dali::Quaternion operator()(const Dali::Quaternion& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
-    {
-      float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
+  void operator()( Dali::Quaternion& current, const Dali::PropertyInputContainer& inputs )
+  {
+    float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
+    float weight = inputs[3]->GetFloat();
 
-      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-    }
+    current = Dali::Quaternion::Slerp( current, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
+  }
 
-    Dali::Toolkit::ItemLayout::QuaternionFunction mWrapMe;
-    unsigned int mItemId;
-  };
+  Dali::Toolkit::ItemLayout::QuaternionFunction mWrapMe;
+  unsigned int mItemId;
+};
 
-  struct WrappedVector3Constraint
+struct WrappedVector3Constraint
+{
+  WrappedVector3Constraint( Dali::Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId )
+  : mWrapMe(wrapMe),
+    mItemId(itemId)
   {
-    WrappedVector3Constraint(Dali::Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId)
-    : mWrapMe(wrapMe),
-      mItemId(itemId)
-    {
-    }
+  }
 
-    Dali::Vector3 operator()(const Dali::Vector3& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
-    {
-      float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
+  void operator()( Dali::Vector3& current, const Dali::PropertyInputContainer& inputs )
+  {
+    float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
+    float weight = inputs[3]->GetFloat();
 
-      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-    }
+    Lerp( current, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
+  }
 
-    Dali::Toolkit::ItemLayout::Vector3Function mWrapMe;
-    unsigned int mItemId;
-  };
+  Dali::Toolkit::ItemLayout::Vector3Function mWrapMe;
+  unsigned int mItemId;
+};
 
-  struct WrappedVector4Constraint
+struct WrappedVector4Constraint
+{
+  WrappedVector4Constraint( Dali::Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId )
+  : mWrapMe(wrapMe),
+    mItemId(itemId)
   {
-    WrappedVector4Constraint(Dali::Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId)
-    : mWrapMe(wrapMe),
-      mItemId(itemId)
-    {
-    }
+  }
 
-    Dali::Vector4 operator()(const Dali::Vector4& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
-    {
-      float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
+  void operator()( Dali::Vector4& current, const Dali::PropertyInputContainer& inputs )
+  {
+    float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
+    float weight = inputs[3]->GetFloat();
 
-      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-    }
+    Lerp( current, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
+  }
 
-    Dali::Toolkit::ItemLayout::Vector4Function mWrapMe;
-    unsigned int mItemId;
-  };
+  Dali::Toolkit::ItemLayout::Vector4Function mWrapMe;
+  unsigned int mItemId;
+};
 
-  struct WrappedBoolConstraint
+struct WrappedBoolConstraint
+{
+  WrappedBoolConstraint( Dali::Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId )
+  : mWrapMe(wrapMe),
+    mItemId(itemId)
   {
-    WrappedBoolConstraint(Dali::Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId)
-    : mWrapMe(wrapMe),
-      mItemId(itemId)
-    {
-    }
+  }
 
-    bool operator()(const bool& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
-    {
-      float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
+  void operator()( bool& current, const Dali::PropertyInputContainer& inputs )
+  {
+    float weight = inputs[3]->GetFloat();
 
-      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
+    if ( weight >= 1.0f )
+    {
+      float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
+      current = mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() );
     }
+  }
 
-    Dali::Toolkit::ItemLayout::BoolFunction mWrapMe;
-    unsigned int mItemId;
-  };
+  Dali::Toolkit::ItemLayout::BoolFunction mWrapMe;
+  unsigned int mItemId;
+};
 
 }  //Unnamed namespace
 
@@ -115,8 +129,9 @@ namespace Toolkit
 {
 
 ItemLayout::ItemLayout()
-: mOrientation(ControlOrientation::Up),
-  mAlphaFunction(Dali::Constraint::DEFAULT_ALPHA_FUNCTION)
+: mOrientation( ControlOrientation::Up ),
+  mAlphaFunction( AlphaFunction::LINEAR ),
+  mWeightObject()
 {
 }
 
@@ -196,18 +211,22 @@ void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float d
     Property::Index scrollSpeedProperty = itemView.GetPropertyIndex("item-view-scroll-speed");
     Property::Index scrollPositionProperty = scrollPositionObject.GetPropertyIndex("scroll-position");
 
+    // We want to animate the layout in so use a weight object to do this
+    if ( !mWeightObject )
+    {
+      mWeightObject = WeightObject::New();
+    }
+
     ItemLayout::Vector3Function positionConstraint;
     if (GetPositionConstraint(itemId, positionConstraint))
     {
       WrappedVector3Constraint wrapped(positionConstraint, itemId);
-      Constraint constraint = Constraint::New<Vector3>( Actor::Property::Position,
-                                                        Source( scrollPositionObject, scrollPositionProperty ),
-                                                        ParentSource( scrollSpeedProperty ),
-                                                        ParentSource( Actor::Property::Size ),
-                                                        wrapped );
-      constraint.SetApplyTime(durationSeconds);
-      constraint.SetAlphaFunction(mAlphaFunction);
-      actor.ApplyConstraint(constraint);
+      Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::POSITION, wrapped );
+      constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
+      constraint.AddSource( ParentSource( scrollSpeedProperty ) );
+      constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
+      constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
+      constraint.Apply();
     }
 
     ItemLayout::QuaternionFunction rotationConstraint;
@@ -215,15 +234,12 @@ void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float d
     {
       WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
 
-      Constraint constraint = Constraint::New<Quaternion>( Actor::Property::Rotation,
-                                                           Source( scrollPositionObject, scrollPositionProperty ),
-                                                           ParentSource( scrollSpeedProperty ),
-                                                           ParentSource( Actor::Property::Size ),
-                                                           wrapped );
-      constraint.SetApplyTime(durationSeconds);
-      constraint.SetAlphaFunction(mAlphaFunction);
-
-      actor.ApplyConstraint(constraint);
+      Constraint constraint = Constraint::New<Quaternion>( actor, Actor::Property::ORIENTATION, wrapped );
+      constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
+      constraint.AddSource( ParentSource( scrollSpeedProperty ) );
+      constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
+      constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
+      constraint.Apply();
     }
 
     ItemLayout::Vector3Function scaleConstraint;
@@ -231,15 +247,12 @@ void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float d
     {
       WrappedVector3Constraint wrapped(scaleConstraint, itemId);
 
-      Constraint constraint = Constraint::New<Vector3>( Actor::Property::Scale,
-                                                        Source( scrollPositionObject, scrollPositionProperty ),
-                                                        ParentSource( scrollSpeedProperty ),
-                                                        ParentSource( Actor::Property::Size ),
-                                                        wrapped );
-      constraint.SetApplyTime(durationSeconds);
-      constraint.SetAlphaFunction(mAlphaFunction);
-
-      actor.ApplyConstraint(constraint);
+      Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::SCALE, wrapped );
+      constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
+      constraint.AddSource( ParentSource( scrollSpeedProperty ) );
+      constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
+      constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
+      constraint.Apply();
     }
 
     ItemLayout::Vector4Function colorConstraint;
@@ -247,17 +260,13 @@ void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float d
     {
       WrappedVector4Constraint wrapped(colorConstraint, itemId);
 
-      Constraint constraint = Constraint::New<Vector4>( Actor::Property::Color,
-                                                        Source( scrollPositionObject, scrollPositionProperty ),
-                                                        ParentSource( scrollSpeedProperty ),
-                                                        ParentSource( Actor::Property::Size ),
-                                                        wrapped );
-
-      constraint.SetApplyTime(durationSeconds);
-      constraint.SetAlphaFunction(mAlphaFunction);
+      Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, wrapped );
+      constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
+      constraint.AddSource( ParentSource( scrollSpeedProperty ) );
+      constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
+      constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
       constraint.SetRemoveAction(Dali::Constraint::Discard);
-
-      actor.ApplyConstraint(constraint);
+      constraint.Apply();
     }
 
     ItemLayout::BoolFunction visibilityConstraint;
@@ -265,20 +274,25 @@ void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float d
     {
       WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
 
-      Constraint constraint = Constraint::New<bool>( Actor::Property::Visible,
-                                                     Source( scrollPositionObject, scrollPositionProperty ),
-                                                     ParentSource( scrollSpeedProperty ),
-                                                     ParentSource( Actor::Property::Size ),
-                                                     wrapped );
-
-      constraint.SetApplyTime(durationSeconds);
-      constraint.SetAlphaFunction(mAlphaFunction);
+      Constraint constraint = Constraint::New<bool>( actor, Actor::Property::VISIBLE, wrapped );
+      constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
+      constraint.AddSource( ParentSource( scrollSpeedProperty ) );
+      constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
+      constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 
       // Release visibility constraints the same time as the color constraint
       constraint.SetRemoveAction(Dali::Constraint::Discard);
 
-      actor.ApplyConstraint(constraint);
+      constraint.Apply();
     }
+
+    KeyFrames keyFrames = KeyFrames::New();
+    keyFrames.Add( 0.0f, 0.0f );
+    keyFrames.Add( 1.0f, 1.0f );
+
+    Animation applyAnimation = Dali::Animation::New( durationSeconds );
+    applyAnimation.AnimateBetween( Property( mWeightObject, WeightObject::WEIGHT ), keyFrames, mAlphaFunction, TimePeriod(durationSeconds) );
+    applyAnimation.Play();
   }
 }