Move the logic of constraint application from ItemView to the layout

Change-Id: I1e8b8e86a8f5a6610bac207176347e68413e36f9
Signed-off-by: Richard Huang <r.huang@samsung.com>

diff --git a/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp b/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp
index 600a882..dc5a456 100644 (file)
--- a/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp
+++ b/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.cpp
@@ -43,12 +43,10 @@ const float DEFAULT_MOUSE_WHEEL_SCROLL_DISTANCE_STEP_PROPORTION = 0.1f;
 const float DEFAULT_MINIMUM_SWIPE_DURATION = 0.45f;
 const float DEFAULT_MAXIMUM_SWIPE_DURATION = 2.6f;
 
 const float DEFAULT_MINIMUM_SWIPE_DURATION = 0.45f;
 const float DEFAULT_MAXIMUM_SWIPE_DURATION = 2.6f;
 

-

 const float DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS = 20.0f; // 1 updates per 20 items
 const int MOUSE_WHEEL_EVENT_FINISHED_TIME_OUT = 500;  // 0.5 second
 
 const float DEFAULT_ANCHORING_DURATION = 1.0f;  // 1 second
 const float DEFAULT_REFRESH_INTERVAL_LAYOUT_POSITIONS = 20.0f; // 1 updates per 20 items
 const int MOUSE_WHEEL_EVENT_FINISHED_TIME_OUT = 500;  // 0.5 second
 
 const float DEFAULT_ANCHORING_DURATION = 1.0f;  // 1 second

-const float DEFAULT_COLOR_VISIBILITY_REMOVE_TIME = 0.5f; // 0.5 second

 
 const float MILLISECONDS_PER_SECONDS = 1000.0f;
 
 
 const float MILLISECONDS_PER_SECONDS = 1000.0f;
 


@@ -66,84 +64,6 @@ const string SCROLL_SPEED_PROPERTY_NAME( "item-view-scroll-speed" );
 const string SCROLL_DIRECTION_PROPERTY_NAME( "item-view-scroll-direction" );
 const string OVERSHOOT_PROPERTY_NAME( "item-view-overshoot" );
 
 const string SCROLL_DIRECTION_PROPERTY_NAME( "item-view-scroll-direction" );
 const string OVERSHOOT_PROPERTY_NAME( "item-view-overshoot" );
 

-// Functors which wrap constraint functions with stored item IDs
-
-struct WrappedVector3Constraint
-{
-  WrappedVector3Constraint(Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId)
-  : mWrapMe(wrapMe),
-    mItemId(itemId)
-  {
-  }
-
-  Vector3 operator()(const Vector3& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
-  {
-    float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
-
-    return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-  }
-
-  Toolkit::ItemLayout::Vector3Function mWrapMe;
-  unsigned int mItemId;
-};
-
-struct WrappedQuaternionConstraint
-{
-  WrappedQuaternionConstraint(Toolkit::ItemLayout::QuaternionFunction wrapMe, unsigned int itemId)
-  : mWrapMe(wrapMe),
-    mItemId(itemId)
-  {
-  }
-
-  Quaternion operator()(const Quaternion& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
-  {
-    float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
-
-    return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-  }
-
-  Toolkit::ItemLayout::QuaternionFunction mWrapMe;
-  unsigned int mItemId;
-};
-
-struct WrappedVector4Constraint
-{
-  WrappedVector4Constraint(Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId)
-  : mWrapMe(wrapMe),
-    mItemId(itemId)
-  {
-  }
-
-  Vector4 operator()(const Vector4& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
-  {
-    float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
-
-    return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-  }
-
-  Toolkit::ItemLayout::Vector4Function mWrapMe;
-  unsigned int mItemId;
-};
-
-struct WrappedBoolConstraint
-{
-  WrappedBoolConstraint(Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId)
-  : mWrapMe(wrapMe),
-    mItemId(itemId)
-  {
-  }
-
-  bool operator()(const bool& current, const PropertyInput& layoutPosition, const PropertyInput& scrollSpeed, const PropertyInput& layoutSize)
-  {
-    float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
-
-    return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
-  }
-
-  Toolkit::ItemLayout::BoolFunction mWrapMe;
-  unsigned int mItemId;
-};
-

 /**
  * Local helper to convert pan distance (in actor coordinates) to the layout-specific scrolling direction
  */
 /**
  * Local helper to convert pan distance (in actor coordinates) to the layout-specific scrolling direction
  */


@@ -528,7 +448,6 @@ void ItemView::ActivateLayout(unsigned int layoutIndex, const Vector3& targetSiz
   // Move the items to the new layout positions...
 
   bool resizeAnimationNeeded(false);
   // Move the items to the new layout positions...
 
   bool resizeAnimationNeeded(false);

-

   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
   {
     unsigned int itemId = iter->first;
   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
   {
     unsigned int itemId = iter->first;


@@ -560,7 +479,7 @@ void ItemView::ActivateLayout(unsigned int layoutIndex, const Vector3& targetSiz
       }
     }
 
       }
     }
 

-    ApplyConstraints(actor, *mActiveLayout, itemId, durationSeconds);
+    mActiveLayout->ApplyConstraints(actor, itemId, durationSeconds, mScrollPositionObject, Self() );

   }
 
   if (resizeAnimationNeeded)
   }
 
   if (resizeAnimationNeeded)


@@ -785,7 +704,7 @@ void ItemView::InsertItem( Item newItem, float durationSeconds )
       moveMe = temp;
 
       iter->second.RemoveConstraints();
       moveMe = temp;
 
       iter->second.RemoveConstraints();

-      ApplyConstraints( iter->second, *mActiveLayout, iter->first, durationSeconds );
+      mActiveLayout->ApplyConstraints(iter->second, iter->first, durationSeconds, mScrollPositionObject, Self() );

     }
 
     // Create last item
     }
 
     // Create last item


@@ -794,7 +713,7 @@ void ItemView::InsertItem( Item newItem, float durationSeconds )
     mItemPool.insert( lastItem );
 
     lastItem.second.RemoveConstraints();
     mItemPool.insert( lastItem );
 
     lastItem.second.RemoveConstraints();

-    ApplyConstraints( lastItem.second, *mActiveLayout, lastItem.first, durationSeconds );
+    mActiveLayout->ApplyConstraints(lastItem.second, lastItem.first, durationSeconds, mScrollPositionObject, Self() );

   }
   else
   {
   }
   else
   {


@@ -859,7 +778,7 @@ void ItemView::InsertItems( const ItemContainer& newItems, float durationSeconds
     else
     {
       iter->second.RemoveConstraints();
     else
     {
       iter->second.RemoveConstraints();

-      ApplyConstraints( iter->second, *mActiveLayout, iter->first, durationSeconds );
+      mActiveLayout->ApplyConstraints( iter->second, iter->first, durationSeconds, mScrollPositionObject, Self() );

     }
   }
 
     }
   }
 


@@ -1048,7 +967,7 @@ void ItemView::SetupActor( Item item, float durationSeconds )
       item.second.SetSize( size );
     }
 
       item.second.SetSize( size );
     }
 

-    ApplyConstraints( item.second, *mActiveLayout, item.first, durationSeconds );
+    mActiveLayout->ApplyConstraints( item.second, item.first, durationSeconds, mScrollPositionObject, Self() );

   }
 }
 
   }
 }
 


@@ -1173,97 +1092,6 @@ bool ItemView::OnMouseWheelEventFinished()
   return false;
 }
 
   return false;
 }
 

-void ItemView::ApplyConstraints(Actor& actor, ItemLayout& layout, unsigned int itemId, float duration)
-{
-  ItemLayout::Vector3Function positionConstraint;
-  if (layout.GetPositionConstraint(itemId, positionConstraint))
-  {
-    WrappedVector3Constraint wrapped(positionConstraint, itemId);
-
-    Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
-                                                      Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
-                                                      ParentSource( mPropertyScrollSpeed ),
-                                                      ParentSource( Actor::SIZE ),
-                                                      wrapped );
-    constraint.SetApplyTime(duration);
-    constraint.SetAlphaFunction(mDefaultAlphaFunction);
-
-    actor.ApplyConstraint(constraint);
-  }
-
-  ItemLayout::QuaternionFunction rotationConstraint;
-  if (layout.GetRotationConstraint(itemId, rotationConstraint))
-  {
-    WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
-
-    Constraint constraint = Constraint::New<Quaternion>( Actor::ROTATION,
-                                                         Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
-                                                         ParentSource( mPropertyScrollSpeed ),
-                                                         ParentSource( Actor::SIZE ),
-                                                         wrapped );
-    constraint.SetApplyTime(duration);
-    constraint.SetAlphaFunction(mDefaultAlphaFunction);
-
-    actor.ApplyConstraint(constraint);
-  }
-
-  ItemLayout::Vector3Function scaleConstraint;
-  if (layout.GetScaleConstraint(itemId, scaleConstraint))
-  {
-    WrappedVector3Constraint wrapped(scaleConstraint, itemId);
-
-    Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
-                                                      Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
-                                                      ParentSource( mPropertyScrollSpeed ),
-                                                      ParentSource( Actor::SIZE ),
-                                                      wrapped );
-    constraint.SetApplyTime(duration);
-    constraint.SetAlphaFunction(mDefaultAlphaFunction);
-
-    actor.ApplyConstraint(constraint);
-  }
-
-  ItemLayout::Vector4Function colorConstraint;
-  if (layout.GetColorConstraint(itemId, colorConstraint))
-  {
-    WrappedVector4Constraint wrapped(colorConstraint, itemId);
-
-    Constraint constraint = Constraint::New<Vector4>( Actor::COLOR,
-                                                      Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
-                                                      ParentSource( mPropertyScrollSpeed ),
-                                                      ParentSource( Actor::SIZE ),
-                                                      wrapped );
-    constraint.SetApplyTime(duration);
-    constraint.SetAlphaFunction(mDefaultAlphaFunction);
-
-    // Release color constraints slowly; this allows ItemView to co-exist with ImageActor fade-in
-    constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
-    constraint.SetRemoveAction(Dali::Constraint::Discard);
-
-    actor.ApplyConstraint(constraint);
-  }
-
-  ItemLayout::BoolFunction visibilityConstraint;
-  if (layout.GetVisibilityConstraint(itemId, visibilityConstraint))
-  {
-    WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
-
-    Constraint constraint = Constraint::New<bool>( Actor::VISIBLE,
-                                                   Source( mScrollPositionObject, ScrollConnector::SCROLL_POSITION ),
-                                                   ParentSource( mPropertyScrollSpeed ),
-                                                   ParentSource( Actor::SIZE ),
-                                                   wrapped );
-    constraint.SetApplyTime(duration);
-    constraint.SetAlphaFunction(mDefaultAlphaFunction);
-
-    // Release visibility constraints the same time as the color constraint
-    constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
-    constraint.SetRemoveAction(Dali::Constraint::Discard);
-
-    actor.ApplyConstraint(constraint);
-  }
-}
-

 void ItemView::ReapplyAllConstraints( float durationSeconds )
 {
   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)
 void ItemView::ReapplyAllConstraints( float durationSeconds )
 {
   for (ConstItemPoolIter iter = mItemPool.begin(); iter != mItemPool.end(); ++iter)


@@ -1272,7 +1100,7 @@ void ItemView::ReapplyAllConstraints( float durationSeconds )
     Actor actor = iter->second;
 
     actor.RemoveConstraints();
     Actor actor = iter->second;
 
     actor.RemoveConstraints();

-    ApplyConstraints(actor, *mActiveLayout, id, durationSeconds);
+    mActiveLayout->ApplyConstraints(actor, id, durationSeconds, mScrollPositionObject, Self());

   }
 
   CalculateDomainSize(Self().GetCurrentSize());
   }
 
   CalculateDomainSize(Self().GetCurrentSize());


@@ -1466,12 +1294,6 @@ void ItemView::OnKeyboardFocusChangeCommitted(Actor commitedFocusableActor)
     int nextItemID = GetItemId(commitedFocusableActor);
     float layoutPosition = GetCurrentLayoutPosition(0);
     Vector3 layoutSize = Self().GetCurrentSize();
     int nextItemID = GetItemId(commitedFocusableActor);
     float layoutPosition = GetCurrentLayoutPosition(0);
     Vector3 layoutSize = Self().GetCurrentSize();

-    Vector3 focusItemPosition = Vector3::ZERO;
-    ItemLayout::Vector3Function itemPositionConstraint;
-    if (mActiveLayout->GetPositionConstraint(nextItemID, itemPositionConstraint))
-    {
-      focusItemPosition = itemPositionConstraint(Vector3::ZERO, layoutPosition + nextItemID, 0.0f, layoutSize);
-    }

 
     float scrollTo = mActiveLayout->GetClosestOnScreenLayoutPosition(nextItemID, layoutPosition, layoutSize);
     ScrollTo(Vector3(0.0f, scrollTo, 0.0f), DEFAULT_KEYBOARD_FOCUS_SCROLL_DURATION);
 
     float scrollTo = mActiveLayout->GetClosestOnScreenLayoutPosition(nextItemID, layoutPosition, layoutSize);
     ScrollTo(Vector3(0.0f, scrollTo, 0.0f), DEFAULT_KEYBOARD_FOCUS_SCROLL_DURATION);


@@ -1584,20 +1406,11 @@ void ItemView::CalculateDomainSize(const Vector3& layoutSize)
 
   if(mActiveLayout)
   {
 
   if(mActiveLayout)
   {

-    ItemLayout::Vector3Function firstItemPositionConstraint;
-    if (mActiveLayout->GetPositionConstraint(0, firstItemPositionConstraint))
-    {
-      firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, 0, 0.0f, layoutSize);
-    }
+    firstItemPosition = mActiveLayout->GetItemPosition( 0,0,layoutSize );

 
     float minLayoutPosition = mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), layoutSize);
     self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);
 
     float minLayoutPosition = mActiveLayout->GetMinimumLayoutPosition(mItemFactory.GetNumberOfItems(), layoutSize);
     self.SetProperty(mPropertyMinimumLayoutPosition, minLayoutPosition);

-
-    ItemLayout::Vector3Function lastItemPositionConstraint;
-    if (mActiveLayout->GetPositionConstraint(fabs(minLayoutPosition), lastItemPositionConstraint))
-    {
-      lastItemPosition = lastItemPositionConstraint(Vector3::ZERO, fabs(minLayoutPosition), 0.0f, layoutSize);
-    }
+    lastItemPosition = mActiveLayout->GetItemPosition( fabs(minLayoutPosition),fabs(minLayoutPosition),layoutSize );

 
     float domainSize;
 
 
     float domainSize;
 


@@ -1645,13 +1458,7 @@ bool ItemView::IsLayoutScrollable(const Vector3& layoutSize)
 
 float ItemView::GetScrollPosition(float layoutPosition, const Vector3& layoutSize) const
 {
 
 float ItemView::GetScrollPosition(float layoutPosition, const Vector3& layoutSize) const
 {

-  Vector3 firstItemPosition(Vector3::ZERO);
-  ItemLayout::Vector3Function firstItemPositionConstraint;
-  if (mActiveLayout->GetPositionConstraint(0, firstItemPositionConstraint))
-  {
-    firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, layoutPosition, 0.0f, layoutSize);
-  }
-
+  Vector3 firstItemPosition( mActiveLayout->GetItemPosition(0, layoutPosition, layoutSize ) );

   return IsHorizontal(mActiveLayout->GetOrientation()) ? firstItemPosition.x: firstItemPosition.y;
 }
 
   return IsHorizontal(mActiveLayout->GetOrientation()) ? firstItemPosition.x: firstItemPosition.y;
 }
 

diff --git a/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h b/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h
index 442d760..164bd8c 100644 (file)
--- a/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h
+++ b/base/dali-toolkit/internal/controls/scrollable/item-view/item-view-impl.h
@@ -267,7 +267,6 @@ public:
    */
   void DoRefresh(float currentLayoutPosition, bool cacheExtra);
 
    */
   void DoRefresh(float currentLayoutPosition, bool cacheExtra);
 

-

   /**
    * @copydoc Toolkit::ItemView::SetItemsParentOrigin
    */
   /**
    * @copydoc Toolkit::ItemView::SetItemsParentOrigin
    */


@@ -402,15 +401,6 @@ private:
   ItemView& operator=(const ItemView& rhs);
 
   /**
   ItemView& operator=(const ItemView& rhs);
 
   /**

-   * Helper to apply constraints to an actor.
-   * @param[in] actor The actor to constrain.
-   * @param[in] layout The active layout.
-   * @param[in] itemId The ID of the item represented by the actor.
-   * @param[in] durationSeconds The time taken to fully constrain the actors.
-   */
-  void ApplyConstraints(Actor& actor, ItemLayout& layout, unsigned int itemId, float durationSeconds);
-
-  /**

    * Helper to re-apply all the constraints after items have been inserted, removed etc.
    * @param[in] durationSeconds The time taken to fully constrain the actors.
    */
    * Helper to re-apply all the constraints after items have been inserted, removed etc.
    * @param[in] durationSeconds The time taken to fully constrain the actors.
    */

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..4bd1ac3 100644 (file)
--- 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,90 @@
  */
 
 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
  */
 
 #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
+{
+  const float DEFAULT_COLOR_VISIBILITY_REMOVE_TIME = 0.5f; // 0.5 second
+
+  // 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
 {
 
 namespace Dali
 {


@@ -24,7 +108,8 @@ namespace Toolkit
 {
 
 ItemLayout::ItemLayout()
 {
 
 ItemLayout::ItemLayout()

-: mOrientation(ControlOrientation::Up)
+: mOrientation(ControlOrientation::Up),
+  mAlphaFunction(Dali::Constraint::DEFAULT_ALPHA_FUNCTION)

 {
 }
 
 {
 }
 


@@ -44,12 +129,7 @@ ControlOrientation::Type ItemLayout::GetOrientation() const
 
 float ItemLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
 {
 
 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;
   Vector3 itemSize;
   GetItemSize(itemID, layoutSize, itemSize);
   Vector3 onScreenArea = (layoutSize - itemSize) * 0.5f;


@@ -243,6 +323,136 @@ float ItemLayout::GetFlickSpeedFactor() const
   return GetScrollSpeedFactor();
 }
 
   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)
+  {
+    ///!ToDo: Remove this once AlphaFunction in itemview is removed
+    if( itemView.GetDefaultAlphaFunction() != Constraint::DEFAULT_ALPHA_FUNCTION )
+    {
+      mAlphaFunction = itemView.GetDefaultAlphaFunction();
+    }
+
+    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);
+
+      // Release color constraints slowly; this allows ItemView to co-exist with ImageActor fade-in
+      constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
+      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.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
+      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
 } // namespace Toolkit
 
 } // namespace Dali

diff --git a/base/dali-toolkit/public-api/controls/scrollable/item-view/item-view.cpp b/base/dali-toolkit/public-api/controls/scrollable/item-view/item-view.cpp
index 0271e1a..3eb3866 100644 (file)
--- a/base/dali-toolkit/public-api/controls/scrollable/item-view/item-view.cpp
+++ b/base/dali-toolkit/public-api/controls/scrollable/item-view/item-view.cpp
@@ -228,7 +228,6 @@ void ItemView::ReplaceItems(const ItemContainer& replacementItems, float duratio
   GetImpl(*this).ReplaceItems( replacementItems, durationSeconds );
 }
 
   GetImpl(*this).ReplaceItems( replacementItems, durationSeconds );
 }
 

-

 void ItemView::SetItemsParentOrigin( const Vector3& parentOrigin )
 {
   GetImpl(*this).SetItemsParentOrigin( parentOrigin );
 void ItemView::SetItemsParentOrigin( const Vector3& parentOrigin )
 {
   GetImpl(*this).SetItemsParentOrigin( parentOrigin );

diff --git a/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h b/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h
index 5a32df0..727709b 100644 (file)
--- a/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h
+++ b/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h
@@ -401,6 +401,41 @@ public:
    */
   virtual float GetFlickSpeedFactor() const;
 
    */
   virtual float GetFlickSpeedFactor() const;
 

+  /*
+   * @brief Applies constraints defined by the layout to an actor.
+   *
+   * @param[in] actor The actor to constrain.
+   * @param[in] itemId The ID of the item represented by the actor.
+   * @param[in] durationSeconds The time taken to fully constrain the actors.
+   * @param[in] scrollPositionObject The object which provides the layout position property.
+   * @param[in] itemViewActor The item view instance which requests the application of constraints.
+   */
+  virtual void ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Constrainable scrollPositionObject, const Actor& itemViewActor );
+
+  /**
+   * @brief Gets the position of a given item
+   *
+   * @param[in] itemID id of the item we want to get its position
+   * @param[in] currentLayoutPosition the current layout position of the item view instance
+   * @param[in] layoutSize the current size of the item view instance
+   * @return The item position (x,y,z)
+   */
+  virtual Vector3 GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const;
+
+  /**
+   * @brief Set the alpha function used when applying constraints
+   *
+   * @param[in] func The alpha function to use.
+   */
+  void SetAlphaFunction(AlphaFunction func);
+
+  /**
+   * @brief Retrieve the alpha function used when applying constraints
+   *
+   * @return The alpha function.
+   */
+  AlphaFunction GetAlphaFunction() const;
+

 protected:
 
   /**
 protected:
 
   /**


@@ -410,7 +445,8 @@ protected:
 
 protected:
 
 
 protected:
 

-  ControlOrientation::Type mOrientation; ///< the orientation of the layout.
+  ControlOrientation::Type mOrientation;   ///< the orientation of the layout.
+  AlphaFunction            mAlphaFunction; ///<Alpha function to be applied when removing/adding constraints

 };
 
 } // namespace Toolkit
 };
 
 } // namespace Toolkit

diff --git a/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-view.h b/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-view.h
index 3b31c91..f8a09f8 100644 (file)
--- a/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-view.h
+++ b/capi/dali-toolkit/public-api/controls/scrollable/item-view/item-view.h
@@ -179,13 +179,15 @@ public:
   /**
    * @brief Set default the alpha function used when applying constraints e.g. during ActivateLayout().
    *
   /**
    * @brief Set default the alpha function used when applying constraints e.g. during ActivateLayout().
    *

+   * @deprecated Use SetAlphaFunction() in the layout

    * @param[in] func The default alpha function to use.
    */
   void SetDefaultAlphaFunction(AlphaFunction func);
 
   /**
    * @param[in] func The default alpha function to use.
    */
   void SetDefaultAlphaFunction(AlphaFunction func);
 
   /**

-   * @brief Retrieve the default alpha function for an animation.
+   * @brief Retrieve the default alpha function used when applying constraints

    *
    *

+   * @deprecated Use GetAlphaFunction() in the layout

    * @return The default alpha function.
    */
   AlphaFunction GetDefaultAlphaFunction() const;
    * @return The default alpha function.
    */
   AlphaFunction GetDefaultAlphaFunction() const;