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

   1 /*
   2  * Copyright (c) 2014 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 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-layout.h>
  19 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view.h>
  20
  21 namespace
  22 {
  23   const float DEFAULT_COLOR_VISIBILITY_REMOVE_TIME = 0.5f; // 0.5 second
  24
  25   // Functors which wrap constraint functions with stored item IDs
  26   struct WrappedQuaternionConstraint
  27   {
  28     WrappedQuaternionConstraint(Dali::Toolkit::ItemLayout::QuaternionFunction wrapMe, unsigned int itemId)
  29     :mWrapMe(wrapMe),
  30      mItemId(itemId)
  31     {
  32     }
  33
  34     Dali::Quaternion operator()(const Dali::Quaternion& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
  35     {
  36       float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
  37
  38       return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
  39     }
  40
  41     Dali::Toolkit::ItemLayout::QuaternionFunction mWrapMe;
  42     unsigned int mItemId;
  43   };
  44
  45   struct WrappedVector3Constraint
  46   {
  47     WrappedVector3Constraint(Dali::Toolkit::ItemLayout::Vector3Function wrapMe, unsigned int itemId)
  48     : mWrapMe(wrapMe),
  49       mItemId(itemId)
  50     {
  51     }
  52
  53     Dali::Vector3 operator()(const Dali::Vector3& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
  54     {
  55       float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
  56
  57       return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
  58     }
  59
  60     Dali::Toolkit::ItemLayout::Vector3Function mWrapMe;
  61     unsigned int mItemId;
  62   };
  63
  64   struct WrappedVector4Constraint
  65   {
  66     WrappedVector4Constraint(Dali::Toolkit::ItemLayout::Vector4Function wrapMe, unsigned int itemId)
  67     : mWrapMe(wrapMe),
  68       mItemId(itemId)
  69     {
  70     }
  71
  72     Dali::Vector4 operator()(const Dali::Vector4& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
  73     {
  74       float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
  75
  76       return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
  77     }
  78
  79     Dali::Toolkit::ItemLayout::Vector4Function mWrapMe;
  80     unsigned int mItemId;
  81   };
  82
  83   struct WrappedBoolConstraint
  84   {
  85     WrappedBoolConstraint(Dali::Toolkit::ItemLayout::BoolFunction wrapMe, unsigned int itemId)
  86     : mWrapMe(wrapMe),
  87       mItemId(itemId)
  88     {
  89     }
  90
  91     bool operator()(const bool& current, const Dali::PropertyInput& layoutPosition, const Dali::PropertyInput& scrollSpeed, const Dali::PropertyInput& layoutSize)
  92     {
  93       float offsetLayoutPosition = layoutPosition.GetFloat() + static_cast<float>(mItemId);
  94
  95       return mWrapMe(current, offsetLayoutPosition, scrollSpeed.GetFloat(), layoutSize.GetVector3());
  96     }
  97
  98     Dali::Toolkit::ItemLayout::BoolFunction mWrapMe;
  99     unsigned int mItemId;
 100   };
 101
 102 }  //Unnamed namespace
 103
 104 namespace Dali
 105 {
 106
 107 namespace Toolkit
 108 {
 109
 110 ItemLayout::ItemLayout()
 111 : mOrientation(ControlOrientation::Up),
 112   mAlphaFunction(Dali::Constraint::DEFAULT_ALPHA_FUNCTION)
 113 {
 114 }
 115
 116 ItemLayout::~ItemLayout()
 117 {
 118 }
 119
 120 void ItemLayout::SetOrientation(ControlOrientation::Type orientation)
 121 {
 122   mOrientation = orientation;
 123 }
 124
 125 ControlOrientation::Type ItemLayout::GetOrientation() const
 126 {
 127   return mOrientation;
 128 }
 129
 130 float ItemLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
 131 {
 132   Vector3 itemPosition = GetItemPosition( itemID, currentLayoutPosition, layoutSize );
 133   Vector3 itemSize;
 134   GetItemSize(itemID, layoutSize, itemSize);
 135   Vector3 onScreenArea = (layoutSize - itemSize) * 0.5f;
 136   if (itemPosition.x < -onScreenArea.x
 137       || itemPosition.x > onScreenArea.x
 138       || itemPosition.y < -onScreenArea.y
 139       || itemPosition.y > onScreenArea.y)
 140   {
 141     // item not within viewable area
 142     // safest thing to do here since we have no idea how the implementation will work is to return the scroll to position
 143     return GetItemScrollToPosition(itemID);
 144   }
 145   return currentLayoutPosition;
 146 }
 147
 148 void ItemLayout::GetXAxisScrollHint(Vector2& scrollHint) const
 149 {
 150   scrollHint = Vector2::ZERO;
 151   Radian scrollAngle(GetScrollDirection());
 152   Vector2 scrollDirection(sinf(scrollAngle), cosf(scrollAngle));
 153   switch(mOrientation)
 154   {
 155     case ControlOrientation::Up:
 156     {
 157       if(fabsf(scrollDirection.y) < Math::MACHINE_EPSILON_1)
 158       {
 159         // we probably want x scrolling
 160         if(scrollDirection.x > 0.0f)
 161         {
 162           // normal positive scrolling
 163           scrollHint = Vector2::XAXIS;
 164         }
 165         else
 166         {
 167           scrollHint = -Vector2::XAXIS;
 168         }
 169       }
 170       break;
 171     }
 172     case ControlOrientation::Down:
 173     {
 174       if(fabsf(scrollDirection.y) < Math::MACHINE_EPSILON_1)
 175       {
 176         // we probably want x scrolling
 177         if(scrollDirection.x > 0.0f)
 178         {
 179           // normal positive scrolling
 180           scrollHint = -Vector2::XAXIS;
 181         }
 182         else
 183         {
 184           scrollHint = Vector2::XAXIS;
 185         }
 186       }
 187       break;
 188     }
 189     case ControlOrientation::Left:
 190     {
 191       // we probably want x scrolling
 192       if(scrollDirection.x > 0.0f)
 193       {
 194         // normal positive scrolling
 195         scrollHint = Vector2::XAXIS;
 196       }
 197       else
 198       {
 199         scrollHint = -Vector2::XAXIS;
 200       }
 201       break;
 202     }
 203     case ControlOrientation::Right:
 204     {
 205       // we probably want x scrolling
 206       if(scrollDirection.x > 0.0f)
 207       {
 208         // normal positive scrolling
 209         scrollHint = -Vector2::XAXIS;
 210       }
 211       else
 212       {
 213         scrollHint = Vector2::XAXIS;
 214       }
 215       break;
 216     }
 217   }
 218 }
 219
 220 void ItemLayout::GetYAxisScrollHint(Vector2& scrollHint) const
 221 {
 222   scrollHint = Vector2::ZERO;
 223   Radian scrollAngle(GetScrollDirection());
 224   Vector2 scrollDirection(sinf(scrollAngle), cosf(scrollAngle));
 225   switch(mOrientation)
 226   {
 227     case ControlOrientation::Up:
 228     {
 229       // we probably want x scrolling
 230       if(scrollDirection.y > 0.0f)
 231       {
 232         // normal positive scrolling
 233         scrollHint = Vector2::YAXIS;
 234       }
 235       else
 236       {
 237         scrollHint = -Vector2::YAXIS;
 238       }
 239       break;
 240     }
 241     case ControlOrientation::Down:
 242     {
 243       // we probably want x scrolling
 244       if(scrollDirection.y > 0.0f)
 245       {
 246         // normal positive scrolling
 247         scrollHint = -Vector2::YAXIS;
 248       }
 249       else
 250       {
 251         scrollHint = Vector2::YAXIS;
 252       }
 253       break;
 254     }
 255     case ControlOrientation::Left:
 256     {
 257       if(fabsf(scrollDirection.x) < Math::MACHINE_EPSILON_1)
 258       {
 259         // we probably want x scrolling
 260         if(scrollDirection.y > 0.0f)
 261         {
 262           // normal positive scrolling
 263           scrollHint = -Vector2::YAXIS;
 264         }
 265         else
 266         {
 267           scrollHint = Vector2::YAXIS;
 268         }
 269       }
 270       break;
 271     }
 272     case ControlOrientation::Right:
 273     {
 274       if(fabsf(scrollDirection.x) < Math::MACHINE_EPSILON_1)
 275       {
 276         // we probably want x scrolling
 277         if(scrollDirection.y > 0.0f)
 278         {
 279           // normal positive scrolling
 280           scrollHint = Vector2::YAXIS;
 281         }
 282         else
 283         {
 284           scrollHint = -Vector2::YAXIS;
 285         }
 286       }
 287       break;
 288     }
 289   }
 290 }
 291
 292 int ItemLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 293 {
 294   switch( direction )
 295   {
 296     case Control::Left:
 297     case Control::Up:
 298     {
 299       itemID--;
 300       if( itemID < 0 )
 301       {
 302         itemID = loopEnabled ? maxItems - 1 : 0;
 303       }
 304       break;
 305     }
 306     case Control::Right:
 307     case Control::Down:
 308     {
 309       itemID++;
 310       if( itemID >= maxItems )
 311       {
 312         itemID = loopEnabled ? 0 : maxItems - 1;
 313       }
 314       break;
 315     }
 316   }
 317   return itemID;
 318 }
 319
 320 float ItemLayout::GetFlickSpeedFactor() const
 321 {
 322   // By default, the speed factor while dragging and swiping is the same.
 323   return GetScrollSpeedFactor();
 324 }
 325
 326 void ItemLayout::ApplyConstraints( Actor& actor, const int itemId, const float durationSeconds, Constrainable scrollPositionObject, const Actor& itemViewActor )
 327 {
 328   // This just implements the default behaviour of constraint application.
 329   // Custom layouts can override this function to apply their custom constraints.
 330   Dali::Toolkit::ItemView itemView = Dali::Toolkit::ItemView::DownCast( itemViewActor );
 331   if(itemView && scrollPositionObject)
 332   {
 333     Property::Index scrollSpeedProperty = itemView.GetPropertyIndex("item-view-scroll-speed");
 334     Property::Index scrollPositionProperty = scrollPositionObject.GetPropertyIndex("scroll-position");
 335
 336     ItemLayout::Vector3Function positionConstraint;
 337     if (GetPositionConstraint(itemId, positionConstraint))
 338     {
 339       WrappedVector3Constraint wrapped(positionConstraint, itemId);
 340       Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
 341                                                         Source( scrollPositionObject, scrollPositionProperty ),
 342                                                         ParentSource( scrollSpeedProperty ),
 343                                                         ParentSource( Actor::SIZE ),
 344                                                         wrapped );
 345       constraint.SetApplyTime(durationSeconds);
 346       constraint.SetAlphaFunction(mAlphaFunction);
 347       actor.ApplyConstraint(constraint);
 348     }
 349
 350     ItemLayout::QuaternionFunction rotationConstraint;
 351     if (GetRotationConstraint(itemId, rotationConstraint))
 352     {
 353       WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
 354
 355       Constraint constraint = Constraint::New<Quaternion>( Actor::ROTATION,
 356                                                            Source( scrollPositionObject, scrollPositionProperty ),
 357                                                            ParentSource( scrollSpeedProperty ),
 358                                                            ParentSource( Actor::SIZE ),
 359                                                            wrapped );
 360       constraint.SetApplyTime(durationSeconds);
 361       constraint.SetAlphaFunction(mAlphaFunction);
 362
 363       actor.ApplyConstraint(constraint);
 364     }
 365
 366     ItemLayout::Vector3Function scaleConstraint;
 367     if (GetScaleConstraint(itemId, scaleConstraint))
 368     {
 369       WrappedVector3Constraint wrapped(scaleConstraint, itemId);
 370
 371       Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
 372                                                         Source( scrollPositionObject, scrollPositionProperty ),
 373                                                         ParentSource( scrollSpeedProperty ),
 374                                                         ParentSource( Actor::SIZE ),
 375                                                         wrapped );
 376       constraint.SetApplyTime(durationSeconds);
 377       constraint.SetAlphaFunction(mAlphaFunction);
 378
 379       actor.ApplyConstraint(constraint);
 380     }
 381
 382     ItemLayout::Vector4Function colorConstraint;
 383     if (GetColorConstraint(itemId, colorConstraint))
 384     {
 385       WrappedVector4Constraint wrapped(colorConstraint, itemId);
 386
 387       Constraint constraint = Constraint::New<Vector4>( Actor::COLOR,
 388                                                         Source( scrollPositionObject, scrollPositionProperty ),
 389                                                         ParentSource( scrollSpeedProperty ),
 390                                                         ParentSource( Actor::SIZE ),
 391                                                         wrapped );
 392
 393       constraint.SetApplyTime(durationSeconds);
 394       constraint.SetAlphaFunction(mAlphaFunction);
 395
 396       // Release color constraints slowly; this allows ItemView to co-exist with ImageActor fade-in
 397       constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
 398       constraint.SetRemoveAction(Dali::Constraint::Discard);
 399
 400       actor.ApplyConstraint(constraint);
 401     }
 402
 403     ItemLayout::BoolFunction visibilityConstraint;
 404     if (GetVisibilityConstraint(itemId, visibilityConstraint))
 405     {
 406       WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
 407
 408       Constraint constraint = Constraint::New<bool>( Actor::VISIBLE,
 409                                                      Source( scrollPositionObject, scrollPositionProperty ),
 410                                                      ParentSource( scrollSpeedProperty ),
 411                                                      ParentSource( Actor::SIZE ),
 412                                                      wrapped );
 413
 414       constraint.SetApplyTime(durationSeconds);
 415       constraint.SetAlphaFunction(mAlphaFunction);
 416
 417       // Release visibility constraints the same time as the color constraint
 418       constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
 419       constraint.SetRemoveAction(Dali::Constraint::Discard);
 420
 421       actor.ApplyConstraint(constraint);
 422     }
 423   }
 424 }
 425
 426 Vector3 ItemLayout::GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const
 427 {
 428   Vector3 itemPosition = Vector3::ZERO;
 429
 430   ItemLayout::Vector3Function positionConstraint;
 431   if (GetPositionConstraint(itemID, positionConstraint))
 432   {
 433     itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
 434   }
 435
 436   return itemPosition;
 437 }
 438
 439 void ItemLayout::SetAlphaFunction(AlphaFunction func)
 440 {
 441   mAlphaFunction = func;
 442 }
 443
 444 AlphaFunction ItemLayout::GetAlphaFunction() const
 445 {
 446   return mAlphaFunction;
 447 }
 448
 449
 450 } // namespace Toolkit
 451
 452 } // namespace Dali