dali-toolkit/public-api/controls/scrollable/item-view/item-layout.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/animation/animation.h>
  23 #include <dali/public-api/animation/constraint.h>
  24 #include <dali/public-api/animation/time-period.h>
  25
  26 // INTERNAL INCLUDES
  27 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
  28
  29 namespace
  30 {
  31
  32 // Lerps between current and target using the progress
  33 template< typename Type >
  34 void Lerp( Type& current, const Type& target, float progress )
  35 {
  36   current += ((target - current) * progress);
  37 }
  38
  39 // Functors which wrap constraint functions with stored item IDs
  40 struct WrappedQuaternionConstraint
  41 {
  42   WrappedQuaternionConstraint( Dali::Toolkit::ItemLayout::QuaternionFunction wrapMe, unsigned int itemId )
  43   :mWrapMe(wrapMe),
  44    mItemId(itemId)
  45   {
  46   }
  47
  48   void operator()( Dali::Quaternion& current, const Dali::PropertyInputContainer& inputs )
  49   {
  50     float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
  51     float weight = inputs[3]->GetFloat();
  52
  53     current = Dali::Quaternion::Slerp( current, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
  54   }
  55
  56   Dali::Toolkit::ItemLayout::QuaternionFunction mWrapMe;
  57   unsigned int mItemId;
  58 };
  59
  60 struct WrappedVector3Constraint
  61 {
  62   WrappedVector3Constraint( Dali::Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId )
  63   : mWrapMe(wrapMe),
  64     mItemId(itemId)
  65   {
  66   }
  67
  68   void operator()( Dali::Vector3& current, const Dali::PropertyInputContainer& inputs )
  69   {
  70     float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
  71     float weight = inputs[3]->GetFloat();
  72
  73     Lerp( current, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
  74   }
  75
  76   Dali::Toolkit::ItemLayout::Vector3Function mWrapMe;
  77   unsigned int mItemId;
  78 };
  79
  80 struct WrappedVector4Constraint
  81 {
  82   WrappedVector4Constraint( Dali::Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId )
  83   : mWrapMe(wrapMe),
  84     mItemId(itemId)
  85   {
  86   }
  87
  88   void operator()( Dali::Vector4& current, const Dali::PropertyInputContainer& inputs )
  89   {
  90     float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
  91     float weight = inputs[3]->GetFloat();
  92
  93     Lerp( current, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
  94   }
  95
  96   Dali::Toolkit::ItemLayout::Vector4Function mWrapMe;
  97   unsigned int mItemId;
  98 };
  99
 100 struct WrappedBoolConstraint
 101 {
 102   WrappedBoolConstraint( Dali::Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId )
 103   : mWrapMe(wrapMe),
 104     mItemId(itemId)
 105   {
 106   }
 107
 108   void operator()( bool& current, const Dali::PropertyInputContainer& inputs )
 109   {
 110     float weight = inputs[3]->GetFloat();
 111
 112     if ( weight >= 1.0f )
 113     {
 114       float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
 115       current = mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() );
 116     }
 117   }
 118
 119   Dali::Toolkit::ItemLayout::BoolFunction mWrapMe;
 120   unsigned int mItemId;
 121 };
 122
 123 }  //Unnamed namespace
 124
 125 namespace Dali
 126 {
 127
 128 namespace Toolkit
 129 {
 130
 131 ItemLayout::ItemLayout()
 132 : mOrientation( ControlOrientation::Up ),
 133   mAlphaFunction( AlphaFunction::LINEAR ),
 134   mWeightObject()
 135 {
 136 }
 137
 138 ItemLayout::~ItemLayout()
 139 {
 140 }
 141
 142 void ItemLayout::SetOrientation(ControlOrientation::Type orientation)
 143 {
 144   mOrientation = orientation;
 145 }
 146
 147 ControlOrientation::Type ItemLayout::GetOrientation() const
 148 {
 149   return mOrientation;
 150 }
 151
 152 float ItemLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
 153 {
 154   Vector3 itemPosition = GetItemPosition( itemID, currentLayoutPosition, layoutSize );
 155   Vector3 itemSize;
 156   GetItemSize(itemID, layoutSize, itemSize);
 157   Vector3 onScreenArea = (layoutSize - itemSize) * 0.5f;
 158   if (itemPosition.x < -onScreenArea.x
 159       || itemPosition.x > onScreenArea.x
 160       || itemPosition.y < -onScreenArea.y
 161       || itemPosition.y > onScreenArea.y)
 162   {
 163     // item not within viewable area
 164     // safest thing to do here since we have no idea how the implementation will work is to return the scroll to position
 165     return GetItemScrollToPosition(itemID);
 166   }
 167   return currentLayoutPosition;
 168 }
 169
 170 int ItemLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 171 {
 172   switch( direction )
 173   {
 174     case Control::Left:
 175     case Control::Up:
 176     {
 177       itemID--;
 178       if( itemID < 0 )
 179       {
 180         itemID = loopEnabled ? maxItems - 1 : 0;
 181       }
 182       break;
 183     }
 184     case Control::Right:
 185     case Control::Down:
 186     {
 187       itemID++;
 188       if( itemID >= maxItems )
 189       {
 190         itemID = loopEnabled ? 0 : maxItems - 1;
 191       }
 192       break;
 193     }
 194   }
 195   return itemID;
 196 }
 197
 198 float ItemLayout::GetFlickSpeedFactor() const
 199 {
 200   // By default, the speed factor while dragging and swiping is the same.
 201   return GetScrollSpeedFactor();
 202 }
 203
 204 void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Handle scrollPositionObject, const Actor& itemViewActor )
 205 {
 206   // This just implements the default behaviour of constraint application.
 207   // Custom layouts can override this function to apply their custom constraints.
 208   Dali::Toolkit::ItemView itemView = Dali::Toolkit::ItemView::DownCast( itemViewActor );
 209   if(itemView && scrollPositionObject)
 210   {
 211     Property::Index scrollSpeedProperty = itemView.GetPropertyIndex("item-view-scroll-speed");
 212     Property::Index scrollPositionProperty = scrollPositionObject.GetPropertyIndex("scroll-position");
 213
 214     // We want to animate the layout in so use a weight object to do this
 215     if ( !mWeightObject )
 216     {
 217       mWeightObject = WeightObject::New();
 218     }
 219
 220     ItemLayout::Vector3Function positionConstraint;
 221     if (GetPositionConstraint(itemId, positionConstraint))
 222     {
 223       WrappedVector3Constraint wrapped(positionConstraint, itemId);
 224       Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::POSITION, wrapped );
 225       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 226       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 227       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 228       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 229       constraint.Apply();
 230     }
 231
 232     ItemLayout::QuaternionFunction rotationConstraint;
 233     if (GetRotationConstraint(itemId, rotationConstraint))
 234     {
 235       WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
 236
 237       Constraint constraint = Constraint::New<Quaternion>( actor, Actor::Property::ORIENTATION, wrapped );
 238       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 239       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 240       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 241       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 242       constraint.Apply();
 243     }
 244
 245     ItemLayout::Vector3Function scaleConstraint;
 246     if (GetScaleConstraint(itemId, scaleConstraint))
 247     {
 248       WrappedVector3Constraint wrapped(scaleConstraint, itemId);
 249
 250       Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::SCALE, wrapped );
 251       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 252       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 253       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 254       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 255       constraint.Apply();
 256     }
 257
 258     ItemLayout::Vector4Function colorConstraint;
 259     if (GetColorConstraint(itemId, colorConstraint))
 260     {
 261       WrappedVector4Constraint wrapped(colorConstraint, itemId);
 262
 263       Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, wrapped );
 264       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 265       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 266       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 267       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 268       constraint.SetRemoveAction(Dali::Constraint::Discard);
 269       constraint.Apply();
 270     }
 271
 272     ItemLayout::BoolFunction visibilityConstraint;
 273     if (GetVisibilityConstraint(itemId, visibilityConstraint))
 274     {
 275       WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
 276
 277       Constraint constraint = Constraint::New<bool>( actor, Actor::Property::VISIBLE, wrapped );
 278       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 279       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 280       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 281       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 282
 283       // Release visibility constraints the same time as the color constraint
 284       constraint.SetRemoveAction(Dali::Constraint::Discard);
 285
 286       constraint.Apply();
 287     }
 288
 289     KeyFrames keyFrames = KeyFrames::New();
 290     keyFrames.Add( 0.0f, 0.0f );
 291     keyFrames.Add( 1.0f, 1.0f );
 292
 293     Animation applyAnimation = Dali::Animation::New( durationSeconds );
 294     applyAnimation.AnimateBetween( Property( mWeightObject, WeightObject::WEIGHT ), keyFrames, mAlphaFunction, TimePeriod(durationSeconds) );
 295     applyAnimation.Play();
 296   }
 297 }
 298
 299 Vector3 ItemLayout::GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const
 300 {
 301   Vector3 itemPosition = Vector3::ZERO;
 302
 303   ItemLayout::Vector3Function positionConstraint;
 304   if (GetPositionConstraint(itemID, positionConstraint))
 305   {
 306     itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
 307   }
 308
 309   return itemPosition;
 310 }
 311
 312 void ItemLayout::SetAlphaFunction(AlphaFunction func)
 313 {
 314   mAlphaFunction = func;
 315 }
 316
 317 AlphaFunction ItemLayout::GetAlphaFunction() const
 318 {
 319   return mAlphaFunction;
 320 }
 321
 322
 323 } // namespace Toolkit
 324
 325 } // namespace Dali