X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=base%2Fdali-toolkit%2Fpublic-api%2Fcontrols%2Fscrollable%2Fitem-view%2Fitem-layout.cpp;h=32aeb7ac177937196e2aef7ef50c64040777c9ee;hp=c4f94f0b4e86023e4e06423d64b3cbf12d3d0ed4;hb=fb7a84118ac4d5ddeb41f9d2d741f6aa51045ee8;hpb=b422e5389b5b78d6037865c77453ab2fb5e47a0d

diff --git a/base/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp b/base/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp
index c4f94f0..32aeb7a 100644
--- a/base/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp
+++ b/base/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp
@@ -16,6 +16,89 @@
  */
 
 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
+#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
+
+namespace
+{
+
+  // Functors which wrap constraint functions with stored item IDs
+  struct WrappedQuaternionConstraint
+  {
+    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);
+
+      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
+    }
+
+    Dali::Toolkit::ItemLayout::QuaternionFunction mWrapMe;
+    unsigned int mItemId;
+  };
+
+  struct WrappedVector3Constraint
+  {
+    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);
+
+      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
+    }
+
+    Dali::Toolkit::ItemLayout::Vector3Function mWrapMe;
+    unsigned int mItemId;
+  };
+
+  struct WrappedVector4Constraint
+  {
+    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);
+
+      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
+    }
+
+    Dali::Toolkit::ItemLayout::Vector4Function mWrapMe;
+    unsigned int mItemId;
+  };
+
+  struct WrappedBoolConstraint
+  {
+    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);
+
+      return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
+    }
+
+    Dali::Toolkit::ItemLayout::BoolFunction mWrapMe;
+    unsigned int mItemId;
+  };
+
+}  //Unnamed namespace
 
 namespace Dali
 {
@@ -24,7 +107,8 @@ namespace Toolkit
 {
 
 ItemLayout::ItemLayout()
-: mOrientation(ControlOrientation::Up)
+: mOrientation(ControlOrientation::Up),
+  mAlphaFunction(Dali::Constraint::DEFAULT_ALPHA_FUNCTION)
 {
 }
 
@@ -44,12 +128,7 @@ ControlOrientation::Type ItemLayout::GetOrientation() const
 
 float ItemLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
 {
-  ItemLayout::Vector3Function positionConstraint;
-  Vector3 itemPosition = Vector3::ZERO;
-  if (GetPositionConstraint(itemID, positionConstraint))
-  {
-    itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
-  }
+  Vector3 itemPosition = GetItemPosition( itemID, currentLayoutPosition, layoutSize );
   Vector3 itemSize;
   GetItemSize(itemID, layoutSize, itemSize);
   Vector3 onScreenArea = (layoutSize - itemSize) * 0.5f;
@@ -243,6 +322,126 @@ float ItemLayout::GetFlickSpeedFactor() const
   return GetScrollSpeedFactor();
 }
 
+void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Constrainable scrollPositionObject, const Actor& itemViewActor )
+{
+  // This just implements the default behaviour of constraint application.
+  // Custom layouts can override this function to apply their custom constraints.
+  Dali::Toolkit::ItemView itemView = Dali::Toolkit::ItemView::DownCast( itemViewActor );
+  if(itemView && scrollPositionObject)
+  {
+    Property::Index scrollSpeedProperty = itemView.GetPropertyIndex("item-view-scroll-speed");
+    Property::Index scrollPositionProperty = scrollPositionObject.GetPropertyIndex("scroll-position");
+
+    ItemLayout::Vector3Function positionConstraint;
+    if (GetPositionConstraint(itemId, positionConstraint))
+    {
+      WrappedVector3Constraint wrapped(positionConstraint, itemId);
+      Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
+                                                        Source( scrollPositionObject, scrollPositionProperty ),
+                                                        ParentSource( scrollSpeedProperty ),
+                                                        ParentSource( Actor::SIZE ),
+                                                        wrapped );
+      constraint.SetApplyTime(durationSeconds);
+      constraint.SetAlphaFunction(mAlphaFunction);
+      actor.ApplyConstraint(constraint);
+    }
+
+    ItemLayout::QuaternionFunction rotationConstraint;
+    if (GetRotationConstraint(itemId, rotationConstraint))
+    {
+      WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
+
+      Constraint constraint = Constraint::New<Quaternion>( Actor::ROTATION,
+                                                           Source( scrollPositionObject, scrollPositionProperty ),
+                                                           ParentSource( scrollSpeedProperty ),
+                                                           ParentSource( Actor::SIZE ),
+                                                           wrapped );
+      constraint.SetApplyTime(durationSeconds);
+      constraint.SetAlphaFunction(mAlphaFunction);
+
+      actor.ApplyConstraint(constraint);
+    }
+
+    ItemLayout::Vector3Function scaleConstraint;
+    if (GetScaleConstraint(itemId, scaleConstraint))
+    {
+      WrappedVector3Constraint wrapped(scaleConstraint, itemId);
+
+      Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
+                                                        Source( scrollPositionObject, scrollPositionProperty ),
+                                                        ParentSource( scrollSpeedProperty ),
+                                                        ParentSource( Actor::SIZE ),
+                                                        wrapped );
+      constraint.SetApplyTime(durationSeconds);
+      constraint.SetAlphaFunction(mAlphaFunction);
+
+      actor.ApplyConstraint(constraint);
+    }
+
+    ItemLayout::Vector4Function colorConstraint;
+    if (GetColorConstraint(itemId, colorConstraint))
+    {
+      WrappedVector4Constraint wrapped(colorConstraint, itemId);
+
+      Constraint constraint = Constraint::New<Vector4>( Actor::COLOR,
+                                                        Source( scrollPositionObject, scrollPositionProperty ),
+                                                        ParentSource( scrollSpeedProperty ),
+                                                        ParentSource( Actor::SIZE ),
+                                                        wrapped );
+
+      constraint.SetApplyTime(durationSeconds);
+      constraint.SetAlphaFunction(mAlphaFunction);
+      constraint.SetRemoveAction(Dali::Constraint::Discard);
+
+      actor.ApplyConstraint(constraint);
+    }
+
+    ItemLayout::BoolFunction visibilityConstraint;
+    if (GetVisibilityConstraint(itemId, visibilityConstraint))
+    {
+      WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
+
+      Constraint constraint = Constraint::New<bool>( Actor::VISIBLE,
+                                                     Source( scrollPositionObject, scrollPositionProperty ),
+                                                     ParentSource( scrollSpeedProperty ),
+                                                     ParentSource( Actor::SIZE ),
+                                                     wrapped );
+
+      constraint.SetApplyTime(durationSeconds);
+      constraint.SetAlphaFunction(mAlphaFunction);
+
+      // Release visibility constraints the same time as the color constraint
+      constraint.SetRemoveAction(Dali::Constraint::Discard);
+
+      actor.ApplyConstraint(constraint);
+    }
+  }
+}
+
+Vector3 ItemLayout::GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const
+{
+  Vector3 itemPosition = Vector3::ZERO;
+
+  ItemLayout::Vector3Function positionConstraint;
+  if (GetPositionConstraint(itemID, positionConstraint))
+  {
+    itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
+  }
+
+  return itemPosition;
+}
+
+void ItemLayout::SetAlphaFunction(AlphaFunction func)
+{
+  mAlphaFunction = func;
+}
+
+AlphaFunction ItemLayout::GetAlphaFunction() const
+{
+  return mAlphaFunction;
+}
+
+
 } // namespace Toolkit
 
 } // namespace Dali