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 initial and target using the progress
  33 template< typename Type >
  34 void Lerp( Type& current, const Type& initial, const Type& target, float progress )
  35 {
  36   current = initial + ((target - initial) * 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    mInitialised( false )
  46   {
  47   }
  48
  49   void operator()( Dali::Quaternion& current, const Dali::PropertyInputContainer& inputs )
  50   {
  51     float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
  52     float weight = inputs[3]->GetFloat();
  53
  54     if( !mInitialised )
  55     {
  56       mInitialised = true;
  57       mInitial = current;
  58     }
  59
  60     current = Dali::Quaternion::Slerp( mInitial, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
  61   }
  62
  63   Dali::Toolkit::ItemLayout::QuaternionFunction mWrapMe;
  64   unsigned int mItemId;
  65   Dali::Quaternion mInitial;
  66   bool mInitialised:1;
  67 };
  68
  69 struct WrappedVector3Constraint
  70 {
  71   WrappedVector3Constraint( Dali::Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId )
  72   : mWrapMe(wrapMe),
  73     mItemId(itemId),
  74     mInitial(),
  75     mInitialised( false )
  76   {
  77   }
  78
  79   void operator()( Dali::Vector3& current, const Dali::PropertyInputContainer& inputs )
  80   {
  81     float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
  82     float weight = inputs[3]->GetFloat();
  83
  84     if( !mInitialised )
  85     {
  86       mInitialised = true;
  87       mInitial = current;
  88     }
  89
  90     Lerp( current, mInitial, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
  91   }
  92
  93   Dali::Toolkit::ItemLayout::Vector3Function mWrapMe;
  94   unsigned int mItemId;
  95   Dali::Vector3 mInitial;
  96   bool mInitialised:1;
  97 };
  98
  99 struct WrappedVector4Constraint
 100 {
 101   WrappedVector4Constraint( Dali::Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId )
 102   : mWrapMe(wrapMe),
 103     mItemId(itemId),
 104     mInitial(),
 105     mInitialised( false )
 106   {
 107   }
 108
 109   void operator()( Dali::Vector4& current, const Dali::PropertyInputContainer& inputs )
 110   {
 111     float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
 112     float weight = inputs[3]->GetFloat();
 113
 114     if( !mInitialised )
 115     {
 116       mInitialised = true;
 117       mInitial = current;
 118     }
 119
 120     Lerp( current, mInitial, mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() ), weight );
 121   }
 122
 123   Dali::Toolkit::ItemLayout::Vector4Function mWrapMe;
 124   unsigned int mItemId;
 125   Dali::Vector4 mInitial;
 126   bool mInitialised:1;
 127 };
 128
 129 struct WrappedBoolConstraint
 130 {
 131   WrappedBoolConstraint( Dali::Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId )
 132   : mWrapMe(wrapMe),
 133     mItemId(itemId)
 134   {
 135   }
 136
 137   void operator()( bool& current, const Dali::PropertyInputContainer& inputs )
 138   {
 139     float weight = inputs[3]->GetFloat();
 140
 141     if ( weight >= 1.0f )
 142     {
 143       float offsetLayoutPosition = inputs[0]->GetFloat() + static_cast<float>(mItemId);
 144       current = mWrapMe( current, offsetLayoutPosition, inputs[1]->GetFloat(), inputs[2]->GetVector3() );
 145     }
 146   }
 147
 148   Dali::Toolkit::ItemLayout::BoolFunction mWrapMe;
 149   unsigned int mItemId;
 150 };
 151
 152 }  //Unnamed namespace
 153
 154 namespace Dali
 155 {
 156
 157 namespace Toolkit
 158 {
 159
 160 ItemLayout::ItemLayout()
 161 : mOrientation( ControlOrientation::Up ),
 162   mAlphaFunction( AlphaFunction::LINEAR ),
 163   mWeightObject()
 164 {
 165 }
 166
 167 ItemLayout::~ItemLayout()
 168 {
 169 }
 170
 171 void ItemLayout::SetOrientation(ControlOrientation::Type orientation)
 172 {
 173   mOrientation = orientation;
 174 }
 175
 176 ControlOrientation::Type ItemLayout::GetOrientation() const
 177 {
 178   return mOrientation;
 179 }
 180
 181 float ItemLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
 182 {
 183   Vector3 itemPosition = GetItemPosition( itemID, currentLayoutPosition, layoutSize );
 184   Vector3 itemSize;
 185   GetItemSize(itemID, layoutSize, itemSize);
 186   Vector3 onScreenArea = (layoutSize - itemSize) * 0.5f;
 187   if (itemPosition.x < -onScreenArea.x
 188       || itemPosition.x > onScreenArea.x
 189       || itemPosition.y < -onScreenArea.y
 190       || itemPosition.y > onScreenArea.y)
 191   {
 192     // item not within viewable area
 193     // safest thing to do here since we have no idea how the implementation will work is to return the scroll to position
 194     return GetItemScrollToPosition(itemID);
 195   }
 196   return currentLayoutPosition;
 197 }
 198
 199 int ItemLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 200 {
 201   switch( direction )
 202   {
 203     case Control::Left:
 204     case Control::Up:
 205     {
 206       itemID--;
 207       if( itemID < 0 )
 208       {
 209         itemID = loopEnabled ? maxItems - 1 : 0;
 210       }
 211       break;
 212     }
 213     case Control::Right:
 214     case Control::Down:
 215     {
 216       itemID++;
 217       if( itemID >= maxItems )
 218       {
 219         itemID = loopEnabled ? 0 : maxItems - 1;
 220       }
 221       break;
 222     }
 223   }
 224   return itemID;
 225 }
 226
 227 float ItemLayout::GetFlickSpeedFactor() const
 228 {
 229   // By default, the speed factor while dragging and swiping is the same.
 230   return GetScrollSpeedFactor();
 231 }
 232
 233 void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Handle scrollPositionObject, const Actor& itemViewActor )
 234 {
 235   // This just implements the default behaviour of constraint application.
 236   // Custom layouts can override this function to apply their custom constraints.
 237   Dali::Toolkit::ItemView itemView = Dali::Toolkit::ItemView::DownCast( itemViewActor );
 238   if(itemView && scrollPositionObject)
 239   {
 240     Property::Index scrollSpeedProperty = itemView.GetPropertyIndex("item-view-scroll-speed");
 241     Property::Index scrollPositionProperty = scrollPositionObject.GetPropertyIndex("scroll-position");
 242
 243     // We want to animate the layout in so use a weight object to do this
 244     if ( !mWeightObject )
 245     {
 246       mWeightObject = WeightObject::New();
 247     }
 248
 249     ItemLayout::Vector3Function positionConstraint;
 250     if (GetPositionConstraint(itemId, positionConstraint))
 251     {
 252       WrappedVector3Constraint wrapped(positionConstraint, itemId);
 253       Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::POSITION, wrapped );
 254       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 255       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 256       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 257       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 258       constraint.Apply();
 259     }
 260
 261     ItemLayout::QuaternionFunction rotationConstraint;
 262     if (GetRotationConstraint(itemId, rotationConstraint))
 263     {
 264       WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
 265
 266       Constraint constraint = Constraint::New<Quaternion>( actor, Actor::Property::ORIENTATION, wrapped );
 267       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 268       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 269       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 270       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 271       constraint.Apply();
 272     }
 273
 274     ItemLayout::Vector3Function scaleConstraint;
 275     if (GetScaleConstraint(itemId, scaleConstraint))
 276     {
 277       WrappedVector3Constraint wrapped(scaleConstraint, itemId);
 278
 279       Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::SCALE, wrapped );
 280       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 281       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 282       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 283       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 284       constraint.Apply();
 285     }
 286
 287     ItemLayout::Vector4Function colorConstraint;
 288     if (GetColorConstraint(itemId, colorConstraint))
 289     {
 290       WrappedVector4Constraint wrapped(colorConstraint, itemId);
 291
 292       Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, wrapped );
 293       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 294       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 295       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 296       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 297       constraint.SetRemoveAction(Dali::Constraint::Discard);
 298       constraint.Apply();
 299     }
 300
 301     ItemLayout::BoolFunction visibilityConstraint;
 302     if (GetVisibilityConstraint(itemId, visibilityConstraint))
 303     {
 304       WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
 305
 306       Constraint constraint = Constraint::New<bool>( actor, Actor::Property::VISIBLE, wrapped );
 307       constraint.AddSource( Source( scrollPositionObject, scrollPositionProperty ) );
 308       constraint.AddSource( ParentSource( scrollSpeedProperty ) );
 309       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 310       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 311
 312       // Release visibility constraints the same time as the color constraint
 313       constraint.SetRemoveAction(Dali::Constraint::Discard);
 314
 315       constraint.Apply();
 316     }
 317
 318     KeyFrames keyFrames = KeyFrames::New();
 319     keyFrames.Add( 0.0f, 0.0f );
 320     keyFrames.Add( 1.0f, 1.0f );
 321
 322     Animation applyAnimation = Dali::Animation::New( durationSeconds );
 323     applyAnimation.AnimateBetween( Property( mWeightObject, WeightObject::WEIGHT ), keyFrames, mAlphaFunction, TimePeriod(durationSeconds) );
 324     applyAnimation.Play();
 325   }
 326 }
 327
 328 Vector3 ItemLayout::GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const
 329 {
 330   Vector3 itemPosition = Vector3::ZERO;
 331
 332   ItemLayout::Vector3Function positionConstraint;
 333   if (GetPositionConstraint(itemID, positionConstraint))
 334   {
 335     itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
 336   }
 337
 338   return itemPosition;
 339 }
 340
 341 void ItemLayout::SetAlphaFunction(AlphaFunction func)
 342 {
 343   mAlphaFunction = func;
 344 }
 345
 346 AlphaFunction ItemLayout::GetAlphaFunction() const
 347 {
 348   return mAlphaFunction;
 349 }
 350
 351
 352 } // namespace Toolkit
 353
 354 } // namespace Dali