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, 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   Toolkit::ItemView itemView = Toolkit::ItemView::DownCast( itemViewActor );
 238   if(itemView)
 239   {
 240     // We want to animate the layout in so use a weight object to do this
 241     if ( !mWeightObject )
 242     {
 243       mWeightObject = WeightObject::New();
 244     }
 245
 246     ItemLayout::Vector3Function positionConstraint;
 247     if (GetPositionConstraint(itemId, positionConstraint))
 248     {
 249       WrappedVector3Constraint wrapped(positionConstraint, itemId);
 250       Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::POSITION, wrapped );
 251       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::LAYOUT_POSITION ) );
 252       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::SCROLL_SPEED ) );
 253       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 254       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 255       constraint.Apply();
 256     }
 257
 258     ItemLayout::QuaternionFunction rotationConstraint;
 259     if (GetRotationConstraint(itemId, rotationConstraint))
 260     {
 261       WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
 262
 263       Constraint constraint = Constraint::New<Quaternion>( actor, Actor::Property::ORIENTATION, wrapped );
 264       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::LAYOUT_POSITION ) );
 265       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::SCROLL_SPEED ) );
 266       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 267       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 268       constraint.Apply();
 269     }
 270
 271     ItemLayout::Vector3Function scaleConstraint;
 272     if (GetScaleConstraint(itemId, scaleConstraint))
 273     {
 274       WrappedVector3Constraint wrapped(scaleConstraint, itemId);
 275
 276       Constraint constraint = Constraint::New<Vector3>( actor, Actor::Property::SCALE, wrapped );
 277       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::LAYOUT_POSITION ) );
 278       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::SCROLL_SPEED ) );
 279       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 280       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 281       constraint.Apply();
 282     }
 283
 284     ItemLayout::Vector4Function colorConstraint;
 285     if (GetColorConstraint(itemId, colorConstraint))
 286     {
 287       WrappedVector4Constraint wrapped(colorConstraint, itemId);
 288
 289       Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, wrapped );
 290       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::LAYOUT_POSITION ) );
 291       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::SCROLL_SPEED ) );
 292       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 293       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 294       constraint.SetRemoveAction(Dali::Constraint::Discard);
 295       constraint.Apply();
 296     }
 297
 298     ItemLayout::BoolFunction visibilityConstraint;
 299     if (GetVisibilityConstraint(itemId, visibilityConstraint))
 300     {
 301       WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
 302
 303       Constraint constraint = Constraint::New<bool>( actor, Actor::Property::VISIBLE, wrapped );
 304       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::LAYOUT_POSITION ) );
 305       constraint.AddSource( ParentSource( Toolkit::ItemView::Property::SCROLL_SPEED ) );
 306       constraint.AddSource( ParentSource( Actor::Property::SIZE ) );
 307       constraint.AddSource( Source( mWeightObject, WeightObject::WEIGHT ) );
 308
 309       // Release visibility constraints the same time as the color constraint
 310       constraint.SetRemoveAction(Dali::Constraint::Discard);
 311
 312       constraint.Apply();
 313     }
 314
 315     KeyFrames keyFrames = KeyFrames::New();
 316     keyFrames.Add( 0.0f, 0.0f );
 317     keyFrames.Add( 1.0f, 1.0f );
 318
 319     Animation applyAnimation = Dali::Animation::New( durationSeconds );
 320     applyAnimation.AnimateBetween( Property( mWeightObject, WeightObject::WEIGHT ), keyFrames, mAlphaFunction, TimePeriod(durationSeconds) );
 321     applyAnimation.Play();
 322   }
 323 }
 324
 325 Vector3 ItemLayout::GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const
 326 {
 327   Vector3 itemPosition = Vector3::ZERO;
 328
 329   ItemLayout::Vector3Function positionConstraint;
 330   if (GetPositionConstraint(itemID, positionConstraint))
 331   {
 332     itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
 333   }
 334
 335   return itemPosition;
 336 }
 337
 338 void ItemLayout::SetAlphaFunction(AlphaFunction func)
 339 {
 340   mAlphaFunction = func;
 341 }
 342
 343 AlphaFunction ItemLayout::GetAlphaFunction() const
 344 {
 345   return mAlphaFunction;
 346 }
 347
 348
 349 } // namespace Toolkit
 350
 351 } // namespace Dali