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     ///!ToDo: Remove this once AlphaFunction in itemview is removed
 334     if( itemView.GetDefaultAlphaFunction() != Constraint::DEFAULT_ALPHA_FUNCTION )
 335     {
 336       mAlphaFunction = itemView.GetDefaultAlphaFunction();
 337     }
 338
 339     Property::Index scrollSpeedProperty = itemView.GetPropertyIndex("item-view-scroll-speed");
 340     Property::Index scrollPositionProperty = scrollPositionObject.GetPropertyIndex("scroll-position");
 341
 342     ItemLayout::Vector3Function positionConstraint;
 343     if (GetPositionConstraint(itemId, positionConstraint))
 344     {
 345       WrappedVector3Constraint wrapped(positionConstraint, itemId);
 346       Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
 347                                                         Source( scrollPositionObject, scrollPositionProperty ),
 348                                                         ParentSource( scrollSpeedProperty ),
 349                                                         ParentSource( Actor::SIZE ),
 350                                                         wrapped );
 351       constraint.SetApplyTime(durationSeconds);
 352       constraint.SetAlphaFunction(mAlphaFunction);
 353       actor.ApplyConstraint(constraint);
 354     }
 355
 356     ItemLayout::QuaternionFunction rotationConstraint;
 357     if (GetRotationConstraint(itemId, rotationConstraint))
 358     {
 359       WrappedQuaternionConstraint wrapped(rotationConstraint, itemId);
 360
 361       Constraint constraint = Constraint::New<Quaternion>( Actor::ROTATION,
 362                                                            Source( scrollPositionObject, scrollPositionProperty ),
 363                                                            ParentSource( scrollSpeedProperty ),
 364                                                            ParentSource( Actor::SIZE ),
 365                                                            wrapped );
 366       constraint.SetApplyTime(durationSeconds);
 367       constraint.SetAlphaFunction(mAlphaFunction);
 368
 369       actor.ApplyConstraint(constraint);
 370     }
 371
 372     ItemLayout::Vector3Function scaleConstraint;
 373     if (GetScaleConstraint(itemId, scaleConstraint))
 374     {
 375       WrappedVector3Constraint wrapped(scaleConstraint, itemId);
 376
 377       Constraint constraint = Constraint::New<Vector3>( Actor::SCALE,
 378                                                         Source( scrollPositionObject, scrollPositionProperty ),
 379                                                         ParentSource( scrollSpeedProperty ),
 380                                                         ParentSource( Actor::SIZE ),
 381                                                         wrapped );
 382       constraint.SetApplyTime(durationSeconds);
 383       constraint.SetAlphaFunction(mAlphaFunction);
 384
 385       actor.ApplyConstraint(constraint);
 386     }
 387
 388     ItemLayout::Vector4Function colorConstraint;
 389     if (GetColorConstraint(itemId, colorConstraint))
 390     {
 391       WrappedVector4Constraint wrapped(colorConstraint, itemId);
 392
 393       Constraint constraint = Constraint::New<Vector4>( Actor::COLOR,
 394                                                         Source( scrollPositionObject, scrollPositionProperty ),
 395                                                         ParentSource( scrollSpeedProperty ),
 396                                                         ParentSource( Actor::SIZE ),
 397                                                         wrapped );
 398
 399       constraint.SetApplyTime(durationSeconds);
 400       constraint.SetAlphaFunction(mAlphaFunction);
 401
 402       // Release color constraints slowly; this allows ItemView to co-exist with ImageActor fade-in
 403       constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
 404       constraint.SetRemoveAction(Dali::Constraint::Discard);
 405
 406       actor.ApplyConstraint(constraint);
 407     }
 408
 409     ItemLayout::BoolFunction visibilityConstraint;
 410     if (GetVisibilityConstraint(itemId, visibilityConstraint))
 411     {
 412       WrappedBoolConstraint wrapped(visibilityConstraint, itemId);
 413
 414       Constraint constraint = Constraint::New<bool>( Actor::VISIBLE,
 415                                                      Source( scrollPositionObject, scrollPositionProperty ),
 416                                                      ParentSource( scrollSpeedProperty ),
 417                                                      ParentSource( Actor::SIZE ),
 418                                                      wrapped );
 419
 420       constraint.SetApplyTime(durationSeconds);
 421       constraint.SetAlphaFunction(mAlphaFunction);
 422
 423       // Release visibility constraints the same time as the color constraint
 424       constraint.SetRemoveTime(DEFAULT_COLOR_VISIBILITY_REMOVE_TIME);
 425       constraint.SetRemoveAction(Dali::Constraint::Discard);
 426
 427       actor.ApplyConstraint(constraint);
 428     }
 429   }
 430 }
 431
 432 Vector3 ItemLayout::GetItemPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize) const
 433 {
 434   Vector3 itemPosition = Vector3::ZERO;
 435
 436   ItemLayout::Vector3Function positionConstraint;
 437   if (GetPositionConstraint(itemID, positionConstraint))
 438   {
 439     itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
 440   }
 441
 442   return itemPosition;
 443 }
 444
 445 void ItemLayout::SetAlphaFunction(AlphaFunction func)
 446 {
 447   mAlphaFunction = func;
 448 }
 449
 450 AlphaFunction ItemLayout::GetAlphaFunction() const
 451 {
 452   return mAlphaFunction;
 453 }
 454
 455
 456 } // namespace Toolkit
 457
 458 } // namespace Dali