base/dali-toolkit/public-api/controls/scrollable/item-view/grid-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 // CLASS HEADER
  19 #include <dali-toolkit/public-api/controls/scrollable/item-view/grid-layout.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23 #include <dali/public-api/animation/animation.h>
  24
  25 using namespace Dali;
  26 using namespace Dali::Toolkit;
  27 using namespace std;
  28
  29 namespace // unnamed namespace
  30 {
  31
  32 const unsigned int DEFAULT_NUMBER_OF_COLUMNS = 4;
  33 const float DEFAULT_TOP_MARGIN     =  95.0f;
  34 const float DEFAULT_BOTTOM_MARGIN  =  20.0f;
  35 const float DEFAULT_SIDE_MARGIN    =  20.0f;
  36 const float DEFAULT_COLUMN_SPACING =  20.0f;
  37 const float DEFAULT_ROW_SPACING    =  20.0f;
  38 const float DEFAULT_SCROLL_SPEED_FACTOR = 0.03f;
  39 const float DEFAULT_MAXIMUM_SWIPE_SPEED = 100.0f;
  40 const float DEFAULT_ITEM_FLICK_ANIMATION_DURATION = 0.015f;
  41
  42 // 4 orientations are supported
  43 static const unsigned int ORIENTATION_COUNT = 4;
  44
  45 static Vector3 GetItemSizeDefaultFunction(unsigned int numberOfColumns, float layoutWidth, float sideMargin, float columnSpacing)
  46 {
  47   float width = (layoutWidth - sideMargin * 2.0f - columnSpacing * static_cast<float>(numberOfColumns - 1)) / static_cast<float>(numberOfColumns);
  48
  49   // 4x3 aspect ratio
  50   return Vector3(width, width * 0.75f, width * 0.75f);
  51 }
  52
  53 struct GridPositionConstraint0
  54 {
  55   GridPositionConstraint0(const unsigned int columnIndex, const unsigned int numberOfColumns, const float rowSpacing, const float columnSpacing, const float topMargin, const float sideMargin, GridLayout::ItemSizeFunction itemSizeFunction, const float gap)
  56   : mColumnIndex(columnIndex),
  57     mNumberOfColumns(numberOfColumns),
  58     mRowSpacing(rowSpacing),
  59     mColumnSpacing(columnSpacing),
  60     mTopMargin(topMargin),
  61     mSideMargin(sideMargin),
  62     mItemSizeFunction(itemSizeFunction),
  63     mZGap(gap)
  64   {
  65   }
  66
  67   Vector3 operator()(const Vector3& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
  68   {
  69     Vector3 itemSize = mItemSizeFunction(mNumberOfColumns, layoutSize.width, mSideMargin, mColumnSpacing);
  70
  71     return Vector3(mSideMargin + (mColumnIndex * (itemSize.x + mColumnSpacing)) + itemSize.x * 0.5f - layoutSize.x * 0.5f,
  72                    ((itemSize.y + mRowSpacing) * (layoutPosition - mColumnIndex)) / mNumberOfColumns - layoutSize.height * 0.5f + itemSize.y * 0.5f + mTopMargin,
  73                    mColumnIndex * mZGap);
  74   }
  75
  76 public:
  77
  78   unsigned int mColumnIndex;
  79   unsigned int mNumberOfColumns;
  80   float mRowSpacing;
  81   float mColumnSpacing;
  82   float mTopMargin;
  83   float mSideMargin;
  84   GridLayout::ItemSizeFunction mItemSizeFunction;
  85   float mZGap;
  86 };
  87
  88 struct GridPositionConstraint90
  89 {
  90   GridPositionConstraint90(const unsigned int columnIndex, const unsigned int numberOfColumns, const float rowSpacing, const float columnSpacing, const float topMargin, const float sideMargin, GridLayout::ItemSizeFunction itemSizeFunction, const float gap)
  91   : mColumnIndex(columnIndex),
  92     mNumberOfColumns(numberOfColumns),
  93     mRowSpacing(rowSpacing),
  94     mColumnSpacing(columnSpacing),
  95     mTopMargin(topMargin),
  96     mSideMargin(sideMargin),
  97     mItemSizeFunction(itemSizeFunction),
  98     mZGap(gap)
  99   {
 100   }
 101
 102   Vector3 operator()(const Vector3& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 103   {
 104     Vector3 itemSize = mItemSizeFunction(mNumberOfColumns, layoutSize.height, mSideMargin, mColumnSpacing);
 105
 106     return Vector3(((itemSize.y + mRowSpacing) * (layoutPosition - mColumnIndex)) / mNumberOfColumns - layoutSize.width * 0.5f + itemSize.y * 0.5f + mTopMargin,
 107                    -(mSideMargin + (mColumnIndex * (itemSize.x + mColumnSpacing)) + itemSize.x * 0.5f - layoutSize.y*0.5f),
 108                    mColumnIndex * mZGap);
 109   }
 110
 111 public:
 112
 113   unsigned int mColumnIndex;
 114   unsigned int mNumberOfColumns;
 115   float mRowSpacing;
 116   float mColumnSpacing;
 117   float mTopMargin;
 118   float mSideMargin;
 119   GridLayout::ItemSizeFunction mItemSizeFunction;
 120   float mZGap;
 121 };
 122
 123 struct GridPositionConstraint180
 124 {
 125   GridPositionConstraint180(const unsigned int columnIndex, const unsigned int numberOfColumns, const float rowSpacing, const float columnSpacing, const float topMargin, const float sideMargin, GridLayout::ItemSizeFunction itemSizeFunction, const float gap)
 126   : mColumnIndex(columnIndex),
 127     mNumberOfColumns(numberOfColumns),
 128     mRowSpacing(rowSpacing),
 129     mColumnSpacing(columnSpacing),
 130     mTopMargin(topMargin),
 131     mSideMargin(sideMargin),
 132     mItemSizeFunction(itemSizeFunction),
 133     mZGap(gap)
 134   {
 135   }
 136
 137   Vector3 operator()(const Vector3& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 138   {
 139     Vector3 itemSize = mItemSizeFunction(mNumberOfColumns, layoutSize.width, mSideMargin, mColumnSpacing);
 140
 141     return Vector3(-(mSideMargin + (mColumnIndex * (itemSize.x + mColumnSpacing)) + itemSize.x * 0.5f - layoutSize.x * 0.5f),
 142                    -(((itemSize.y + mRowSpacing) * (layoutPosition - mColumnIndex)) / mNumberOfColumns - layoutSize.height * 0.5f + itemSize.y * 0.5f + mTopMargin),
 143                    mColumnIndex * mZGap);
 144   }
 145
 146 public:
 147
 148   unsigned int mColumnIndex;
 149   unsigned int mNumberOfColumns;
 150   float mRowSpacing;
 151   float mColumnSpacing;
 152   float mTopMargin;
 153   float mSideMargin;
 154   GridLayout::ItemSizeFunction mItemSizeFunction;
 155   float mZGap;
 156 };
 157
 158 struct GridPositionConstraint270
 159 {
 160   GridPositionConstraint270(const unsigned int columnIndex, const unsigned int numberOfColumns, const float rowSpacing, const float columnSpacing, const float topMargin, const float sideMargin, GridLayout::ItemSizeFunction itemSizeFunction, const float gap)
 161   : mColumnIndex(columnIndex),
 162     mNumberOfColumns(numberOfColumns),
 163     mRowSpacing(rowSpacing),
 164     mColumnSpacing(columnSpacing),
 165     mTopMargin(topMargin),
 166     mSideMargin(sideMargin),
 167     mItemSizeFunction(itemSizeFunction),
 168     mZGap(gap)
 169   {
 170   }
 171
 172   Vector3 operator()(const Vector3& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 173   {
 174     Vector3 itemSize = mItemSizeFunction(mNumberOfColumns, layoutSize.height, mSideMargin, mColumnSpacing);
 175
 176     return Vector3(-(((itemSize.y + mRowSpacing) * (layoutPosition - mColumnIndex)) / mNumberOfColumns - layoutSize.width * 0.5f + itemSize.y * 0.5f + mTopMargin),
 177                    mSideMargin + (mColumnIndex * (itemSize.x + mColumnSpacing)) + itemSize.x * 0.5f - layoutSize.y * 0.5f,
 178                    mColumnIndex * mZGap);
 179   }
 180
 181 public:
 182
 183   unsigned int mColumnIndex;
 184   unsigned int mNumberOfColumns;
 185   float mRowSpacing;
 186   float mColumnSpacing;
 187   float mTopMargin;
 188   float mSideMargin;
 189   GridLayout::ItemSizeFunction mItemSizeFunction;
 190   float mZGap;
 191 };
 192
 193 struct GridRotationConstraint0
 194 {
 195   Quaternion operator()(const Quaternion& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 196   {
 197     return Quaternion(0.0f, Vector3::ZAXIS);
 198   }
 199 };
 200
 201 struct GridRotationConstraint90
 202 {
 203   Quaternion operator()(const Quaternion& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 204   {
 205     return Quaternion(1.5f * Math::PI, Vector3::ZAXIS);
 206   }
 207 };
 208
 209 struct GridRotationConstraint180
 210 {
 211   Quaternion operator()(const Quaternion& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 212   {
 213     return Quaternion(Math::PI, Vector3::ZAXIS);
 214   }
 215 };
 216
 217 struct GridRotationConstraint270
 218 {
 219   Quaternion operator()(const Quaternion& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 220   {
 221     return Quaternion(0.5f * Math::PI, Vector3::ZAXIS);
 222   }
 223 };
 224
 225 struct GridColorConstraint
 226 {
 227   Vector4 operator()(const Vector4& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 228   {
 229     return Vector4( 1.0f, 1.0f, 1.0f, current.a );
 230   }
 231 };
 232
 233 struct GridVisibilityConstraintPortrait
 234 {
 235   GridVisibilityConstraintPortrait(const unsigned int columnIndex, const unsigned int numberOfColumns, const float rowSpacing, const float columnSpacing, const float sideMargin, GridLayout::ItemSizeFunction itemSizeFunction)
 236   : mColumnIndex(columnIndex),
 237     mNumberOfColumns(numberOfColumns),
 238     mRowSpacing(rowSpacing),
 239     mColumnSpacing(columnSpacing),
 240     mSideMargin(sideMargin),
 241     mItemSizeFunction(itemSizeFunction)
 242   {
 243   }
 244
 245   bool operator()(const bool& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 246   {
 247     Vector3 itemSize = mItemSizeFunction(mNumberOfColumns, layoutSize.width, mSideMargin, mColumnSpacing);
 248
 249     float row = (layoutPosition - static_cast<float>(mColumnIndex)) / mNumberOfColumns;
 250     int rowsPerPage = ceil(layoutSize.height / (itemSize.y + mRowSpacing));
 251
 252     return (row > -2.0f) && (row < rowsPerPage);
 253   }
 254
 255 public:
 256
 257   unsigned int mColumnIndex;
 258   unsigned int mNumberOfColumns;
 259   float mRowSpacing;
 260   float mColumnSpacing;
 261   float mSideMargin;
 262   GridLayout::ItemSizeFunction mItemSizeFunction;
 263 };
 264
 265 struct GridVisibilityConstraintLandscape
 266 {
 267   GridVisibilityConstraintLandscape(const unsigned int columnIndex, const unsigned int numberOfColumns, const float rowSpacing, const float columnSpacing, const float sideMargin, GridLayout::ItemSizeFunction itemSizeFunction)
 268   : mColumnIndex(columnIndex),
 269     mNumberOfColumns(numberOfColumns),
 270     mRowSpacing(rowSpacing),
 271     mColumnSpacing(columnSpacing),
 272     mSideMargin(sideMargin),
 273     mItemSizeFunction(itemSizeFunction)
 274   {
 275   }
 276
 277   bool operator()(const bool& current, const float& layoutPosition, const float& scrollSpeed, const Vector3& layoutSize)
 278   {
 279     Vector3 itemSize = mItemSizeFunction(mNumberOfColumns, layoutSize.height, mSideMargin, mColumnSpacing);
 280
 281     float row = (layoutPosition - static_cast<float>(mColumnIndex)) / mNumberOfColumns;
 282     int rowsPerPage = ceil(layoutSize.width / (itemSize.y + mRowSpacing));
 283
 284     return (row > -2.0f) && (row < rowsPerPage);
 285   }
 286
 287 public:
 288
 289   unsigned int mColumnIndex;
 290   unsigned int mNumberOfColumns;
 291   float mRowSpacing;
 292   float mColumnSpacing;
 293   float mSideMargin;
 294   GridLayout::ItemSizeFunction mItemSizeFunction;
 295 };
 296
 297 } // unnamed namespace
 298
 299 namespace Dali
 300 {
 301
 302 namespace Toolkit
 303 {
 304
 305 struct GridLayout::Impl
 306 {
 307   Impl()
 308   : mNumberOfColumns(DEFAULT_NUMBER_OF_COLUMNS),
 309     mRowSpacing(DEFAULT_ROW_SPACING),
 310     mColumnSpacing(DEFAULT_COLUMN_SPACING),
 311     mTopMargin(DEFAULT_TOP_MARGIN),
 312     mBottomMargin(DEFAULT_BOTTOM_MARGIN),
 313     mSideMargin(DEFAULT_SIDE_MARGIN),
 314     mScrollSpeedFactor(DEFAULT_SCROLL_SPEED_FACTOR),
 315     mMaximumSwipeSpeed(DEFAULT_MAXIMUM_SWIPE_SPEED),
 316     mItemFlickAnimationDuration(DEFAULT_ITEM_FLICK_ANIMATION_DURATION),
 317     mItemSizeFunction(GetItemSizeDefaultFunction)
 318   {
 319     mColorConstraint = GridColorConstraint();
 320
 321     mRotationConstraint[0] = GridRotationConstraint0();
 322     mRotationConstraint[1] = GridRotationConstraint90();
 323     mRotationConstraint[2] = GridRotationConstraint180();
 324     mRotationConstraint[3] = GridRotationConstraint270();
 325   }
 326
 327   unsigned int mNumberOfColumns;
 328   float mRowSpacing;
 329   float mColumnSpacing;
 330   float mTopMargin;
 331   float mBottomMargin;
 332   float mSideMargin;
 333   float mZGap;
 334
 335   float mScrollSpeedFactor;
 336   float mMaximumSwipeSpeed;
 337   float mItemFlickAnimationDuration;
 338
 339   ItemLayout::QuaternionFunction mRotationConstraint[ORIENTATION_COUNT];
 340   ItemLayout::Vector4Function mColorConstraint;
 341
 342   ItemSizeFunction mItemSizeFunction;
 343 };
 344
 345 GridLayoutPtr GridLayout::New()
 346 {
 347   return GridLayoutPtr(new GridLayout());
 348 }
 349
 350 GridLayout::~GridLayout()
 351 {
 352   delete mImpl;
 353 }
 354
 355 void GridLayout::SetNumberOfColumns(unsigned int columns)
 356 {
 357   mImpl->mNumberOfColumns = columns;
 358 }
 359
 360 unsigned int GridLayout::GetNumberOfColumns() const
 361 {
 362   return mImpl->mNumberOfColumns;
 363 }
 364
 365 void GridLayout::SetRowSpacing(float spacing)
 366 {
 367   mImpl->mRowSpacing = spacing;
 368 }
 369
 370 float GridLayout::GetRowSpacing() const
 371 {
 372   return mImpl->mRowSpacing;
 373 }
 374
 375 void GridLayout::SetColumnSpacing(float spacing)
 376 {
 377   mImpl->mColumnSpacing = spacing;
 378 }
 379
 380 float GridLayout::GetColumnSpacing() const
 381 {
 382   return mImpl->mColumnSpacing;
 383 }
 384
 385 void GridLayout::SetTopMargin(float margin)
 386 {
 387   mImpl->mTopMargin = margin;
 388 }
 389
 390 float GridLayout::GetTopMargin() const
 391 {
 392   return mImpl->mTopMargin;
 393 }
 394
 395 void GridLayout::SetBottomMargin(float margin)
 396 {
 397   mImpl->mBottomMargin = margin;
 398 }
 399
 400 float GridLayout::GetBottomMargin() const
 401 {
 402   return mImpl->mBottomMargin;
 403 }
 404
 405 void GridLayout::SetSideMargin(float margin)
 406 {
 407   mImpl->mSideMargin = margin;
 408 }
 409
 410 float GridLayout::GetSideMargin() const
 411 {
 412   return mImpl->mSideMargin;
 413 }
 414
 415 void GridLayout::SetZGap(float gap)
 416 {
 417   mImpl->mZGap = gap;
 418 }
 419
 420 float GridLayout::GetZGap() const
 421 {
 422   return mImpl->mZGap;
 423 }
 424
 425 void GridLayout::SetItemSizeFunction(ItemSizeFunction function)
 426 {
 427   mImpl->mItemSizeFunction = function;
 428 }
 429
 430 GridLayout::ItemSizeFunction GridLayout::GetItemSizeFunction() const
 431 {
 432   return mImpl->mItemSizeFunction;
 433 }
 434
 435 void GridLayout::SetScrollSpeedFactor(float scrollSpeed)
 436 {
 437   mImpl->mScrollSpeedFactor = scrollSpeed;
 438 }
 439
 440 void GridLayout::SetMaximumSwipeSpeed(float speed)
 441 {
 442   mImpl->mMaximumSwipeSpeed = speed;
 443 }
 444
 445 void GridLayout::SetItemFlickAnimationDuration(float durationSeconds)
 446 {
 447   mImpl->mItemFlickAnimationDuration = durationSeconds;
 448 }
 449
 450 float GridLayout::GetScrollSpeedFactor() const
 451 {
 452   return mImpl->mScrollSpeedFactor;
 453 }
 454
 455 float GridLayout::GetMaximumSwipeSpeed() const
 456 {
 457   return mImpl->mMaximumSwipeSpeed;
 458 }
 459
 460 float GridLayout::GetItemFlickAnimationDuration() const
 461 {
 462   return mImpl->mItemFlickAnimationDuration;
 463 }
 464
 465 float GridLayout::GetMinimumLayoutPosition(unsigned int numberOfItems, Vector3 layoutSize) const
 466 {
 467   float layoutWidth = IsHorizontal(mOrientation) ? layoutSize.height : layoutSize.width;
 468   float layoutHeight = IsHorizontal(mOrientation) ? layoutSize.width : layoutSize.height;
 469
 470   Vector3 itemSize = mImpl->mItemSizeFunction( mImpl->mNumberOfColumns, layoutWidth, mImpl->mSideMargin, mImpl->mColumnSpacing);
 471
 472   unsigned int itemsLastRow = numberOfItems % mImpl->mNumberOfColumns;
 473   if (itemsLastRow == 0)
 474   {
 475     itemsLastRow = mImpl->mNumberOfColumns;
 476   }
 477
 478   float rowsLastPage = (layoutHeight - mImpl->mBottomMargin - mImpl->mTopMargin + mImpl->mRowSpacing) / (itemSize.y + mImpl->mRowSpacing);
 479   float itemsLastPage = (rowsLastPage - 1.0f) * static_cast<float>(mImpl->mNumberOfColumns) + static_cast<float>(itemsLastRow);
 480
 481   return itemsLastPage - static_cast<float>(numberOfItems);
 482 }
 483
 484 float GridLayout::GetClosestAnchorPosition(float layoutPosition) const
 485 {
 486   float rowIndex = static_cast<float>(round(layoutPosition / mImpl->mNumberOfColumns));
 487   return rowIndex * static_cast<float>(mImpl->mNumberOfColumns);
 488 }
 489
 490 float GridLayout::GetItemScrollToPosition(unsigned int itemId) const
 491 {
 492   float rowIndex = static_cast<float>(itemId / mImpl->mNumberOfColumns);
 493   return -rowIndex * static_cast<float>(mImpl->mNumberOfColumns);
 494 }
 495
 496 ItemRange GridLayout::GetItemsWithinArea(float firstItemPosition, Vector3 layoutSize) const
 497 {
 498   float layoutWidth = IsHorizontal(mOrientation) ? layoutSize.height : layoutSize.width;
 499   float layoutHeight = IsHorizontal(mOrientation) ? layoutSize.width : layoutSize.height;
 500
 501   Vector3 itemSize = mImpl->mItemSizeFunction( mImpl->mNumberOfColumns, layoutWidth, mImpl->mSideMargin, mImpl->mColumnSpacing);
 502
 503   int itemsPerPage = mImpl->mNumberOfColumns * ceil(layoutHeight / (itemSize.y + mImpl->mRowSpacing));
 504   int firstVisibleItem = -(static_cast<int>(firstItemPosition / mImpl->mNumberOfColumns)) * mImpl->mNumberOfColumns;
 505
 506   int firstItemIndex = std::max(0, firstVisibleItem - static_cast<int>(mImpl->mNumberOfColumns));
 507   int lastItemIndex  = std::max(0, firstVisibleItem + itemsPerPage);
 508
 509   return ItemRange(firstItemIndex, lastItemIndex);
 510 }
 511
 512 float GridLayout::GetClosestOnScreenLayoutPosition(int itemID, float currentLayoutPosition, const Vector3& layoutSize)
 513 {
 514   ItemLayout::Vector3Function positionConstraint;
 515   Vector3 itemPosition = Vector3::ZERO;
 516   if (GetPositionConstraint(itemID, positionConstraint))
 517   {
 518     itemPosition = positionConstraint(Vector3::ZERO, currentLayoutPosition + itemID, 0.0f, layoutSize);
 519   }
 520   Vector3 itemSize;
 521   GetItemSize(itemID, layoutSize, itemSize);
 522   Vector3 onScreenArea = (layoutSize - (IsVertical(mOrientation) ? itemSize : Vector3(itemSize.y, itemSize.x, itemSize.z))) * 0.5f;
 523   if (itemPosition.x < -onScreenArea.x
 524       || itemPosition.x > onScreenArea.x
 525       || itemPosition.y < -onScreenArea.y
 526       || itemPosition.y > onScreenArea.y)
 527   {
 528     // item not within viewable area
 529     float rowHeight = itemSize.y + mImpl->mRowSpacing;
 530     ItemLayout::Vector3Function firstItemPositionConstraint;
 531     Vector3 firstItemPosition = Vector3::ZERO;
 532     float offset = 0.0f;
 533     if (GetPositionConstraint(0, firstItemPositionConstraint))
 534     {
 535       firstItemPosition = firstItemPositionConstraint(Vector3::ZERO, 0.0f, 0.0f, layoutSize);
 536     }
 537     switch( mOrientation )
 538     {
 539       case ControlOrientation::Up:
 540       {
 541         if(itemPosition.y > onScreenArea.y)
 542         {
 543           offset = ((layoutSize.y - rowHeight) * 0.5f) - firstItemPosition.y;
 544         }
 545         else
 546         {
 547           offset = ((-layoutSize.y + rowHeight) * 0.5f) - firstItemPosition.y;
 548         }
 549         break;
 550       }
 551       case ControlOrientation::Down:
 552       {
 553         if(itemPosition.y < -onScreenArea.y)
 554         {
 555           offset = ((layoutSize.y - rowHeight) * 0.5f) - firstItemPosition.y;
 556         }
 557         else
 558         {
 559           offset = ((-layoutSize.y + rowHeight) * 0.5f) - firstItemPosition.y;
 560         }
 561         break;
 562       }
 563       case ControlOrientation::Left:
 564       {
 565         if(itemPosition.x > onScreenArea.x)
 566         {
 567           offset = ((layoutSize.x - rowHeight) * 0.5f) - firstItemPosition.x;
 568         }
 569         else
 570         {
 571           offset = ((-layoutSize.x + rowHeight) * 0.5f) - firstItemPosition.x;
 572         }
 573         break;
 574       }
 575       case ControlOrientation::Right:
 576       {
 577         if(itemPosition.x < -onScreenArea.x)
 578         {
 579           offset = ((layoutSize.x - rowHeight) * 0.5f) - firstItemPosition.x;
 580         }
 581         else
 582         {
 583           offset = ((-layoutSize.x + rowHeight) * 0.5f) - firstItemPosition.x;
 584         }
 585         break;
 586       }
 587     }
 588     // work out number of rows from first item position to an item aligned to bottom of screen
 589     float rowDiff = offset / rowHeight;
 590     float layoutPositionOffset = rowDiff * mImpl->mNumberOfColumns;
 591     float scrollTo = GetItemScrollToPosition(itemID) + layoutPositionOffset;
 592     return scrollTo;
 593   }
 594   return currentLayoutPosition;
 595 }
 596
 597 unsigned int GridLayout::GetReserveItemCount(Vector3 layoutSize) const
 598 {
 599   float layoutWidth = IsHorizontal(mOrientation) ? layoutSize.height : layoutSize.width;
 600   float layoutHeight = IsHorizontal(mOrientation) ? layoutSize.width : layoutSize.height;
 601
 602   Vector3 itemSize = mImpl->mItemSizeFunction( mImpl->mNumberOfColumns, layoutWidth, mImpl->mSideMargin, mImpl->mColumnSpacing);
 603   int itemsPerPage = mImpl->mNumberOfColumns * ceil(layoutHeight / (itemSize.y + mImpl->mRowSpacing));
 604   return itemsPerPage;
 605 }
 606
 607 bool GridLayout::GetItemSize(unsigned int itemId, Vector3 layoutSize, Vector3& itemSize) const
 608 {
 609   // Note: itemId is not checked, since every item has the same size
 610
 611   itemSize = mImpl->mItemSizeFunction( mImpl->mNumberOfColumns, (IsHorizontal(mOrientation) ? layoutSize.height : layoutSize.width), mImpl->mSideMargin, mImpl->mColumnSpacing);
 612   return true;
 613 }
 614
 615 void GridLayout::GetResizeAnimation(Animation& animation, Actor actor, Vector3 size, float durationSeconds) const
 616 {
 617   if(animation)
 618   {
 619     Vector3 currentSize( actor.GetCurrentSize() );
 620     Vector3 shrink( currentSize );
 621
 622     shrink.width = min(size.width, currentSize.width);
 623     shrink.height = min(size.height, currentSize.height);
 624
 625     // Do a nonlinear size animation to shrink the actor first when the actor size changes,
 626     // so that we can avoid the actors overlapping during orientation change.
 627     animation.Resize( actor, shrink, AlphaFunctions::EaseOut, 0.0f, durationSeconds * 0.5f );
 628     animation.Resize( actor, size, AlphaFunctions::EaseIn, 0.0f, durationSeconds );
 629   }
 630 }
 631
 632 bool GridLayout::GetPositionConstraint(unsigned int itemId, ItemLayout::Vector3Function& constraint) const
 633 {
 634   unsigned int columnIndex = itemId % mImpl->mNumberOfColumns;
 635
 636   if (mOrientation == ControlOrientation::Up)
 637   {
 638     constraint = GridPositionConstraint0(columnIndex, mImpl->mNumberOfColumns, mImpl->mRowSpacing, mImpl->mColumnSpacing, mImpl->mTopMargin, mImpl->mSideMargin, mImpl->mItemSizeFunction, mImpl->mZGap);
 639   }
 640   else if (mOrientation == ControlOrientation::Left)
 641   {
 642     constraint = GridPositionConstraint90(columnIndex, mImpl->mNumberOfColumns, mImpl->mRowSpacing, mImpl->mColumnSpacing, mImpl->mTopMargin, mImpl->mSideMargin, mImpl->mItemSizeFunction, mImpl->mZGap);
 643   }
 644   else if (mOrientation == ControlOrientation::Down)
 645   {
 646     constraint = GridPositionConstraint180(columnIndex, mImpl->mNumberOfColumns, mImpl->mRowSpacing, mImpl->mColumnSpacing, mImpl->mTopMargin, mImpl->mSideMargin, mImpl->mItemSizeFunction, mImpl->mZGap);
 647   }
 648   else // mOrientation == ControlOrientation::Right
 649   {
 650     constraint = GridPositionConstraint270(columnIndex, mImpl->mNumberOfColumns, mImpl->mRowSpacing, mImpl->mColumnSpacing, mImpl->mTopMargin, mImpl->mSideMargin, mImpl->mItemSizeFunction, mImpl->mZGap);
 651   }
 652
 653   return true;
 654 }
 655
 656 bool GridLayout::GetRotationConstraint(unsigned int itemId, ItemLayout::QuaternionFunction& constraint) const
 657 {
 658   constraint = mImpl->mRotationConstraint[mOrientation];
 659   return true;
 660 }
 661
 662 bool GridLayout::GetScaleConstraint(unsigned int itemId, ItemLayout::Vector3Function& constraint) const
 663 {
 664   return false; // No scaling
 665 }
 666
 667 bool GridLayout::GetColorConstraint(unsigned int itemId, ItemLayout::Vector4Function& constraint) const
 668 {
 669   constraint = mImpl->mColorConstraint;
 670   return true;
 671 }
 672
 673 bool GridLayout::GetVisibilityConstraint(unsigned int itemId, ItemLayout::BoolFunction& constraint) const
 674 {
 675   unsigned int columnIndex = itemId % mImpl->mNumberOfColumns;
 676
 677   if (IsVertical(mOrientation))
 678   {
 679     constraint = GridVisibilityConstraintPortrait(columnIndex, mImpl->mNumberOfColumns, mImpl->mRowSpacing, mImpl->mColumnSpacing, mImpl->mSideMargin, mImpl->mItemSizeFunction);
 680   }
 681   else // horizontal
 682   {
 683     constraint = GridVisibilityConstraintLandscape(columnIndex, mImpl->mNumberOfColumns, mImpl->mRowSpacing, mImpl->mColumnSpacing, mImpl->mSideMargin, mImpl->mItemSizeFunction);
 684   }
 685
 686   return true;
 687 }
 688
 689 Degree GridLayout::GetScrollDirection() const
 690 {
 691   Degree scrollDirection(0.0f);
 692
 693   if (mOrientation == ControlOrientation::Up)
 694   {
 695     scrollDirection = 0.0f;
 696   }
 697   else if (mOrientation == ControlOrientation::Left)
 698   {
 699     scrollDirection = 90.0f;
 700   }
 701   else if (mOrientation == ControlOrientation::Down)
 702   {
 703     scrollDirection = 180.0f;
 704   }
 705   else // mOrientation == ControlOrientation::Right
 706   {
 707     scrollDirection = 270.0f;
 708   }
 709
 710   return scrollDirection;
 711 }
 712
 713 int GridLayout::GetNextFocusItemID(int itemID, int maxItems, Dali::Toolkit::Control::KeyboardFocusNavigationDirection direction, bool loopEnabled)
 714 {
 715   switch( direction )
 716   {
 717     case Control::Left:
 718     {
 719       itemID--;
 720       if( itemID < 0 )
 721       {
 722         itemID = loopEnabled ? maxItems - 1 : 0;
 723       }
 724       break;
 725     }
 726     case Control::Up:
 727     {
 728       itemID -= mImpl->mNumberOfColumns;
 729       if( itemID < 0 )
 730       {
 731         itemID = loopEnabled ? itemID + maxItems : itemID + mImpl->mNumberOfColumns;
 732       }
 733       break;
 734     }
 735     case Control::Right:
 736     {
 737       itemID++;
 738       if( itemID >= maxItems )
 739       {
 740         itemID = loopEnabled ? 0 : maxItems - 1;
 741       }
 742       break;
 743     }
 744     case Control::Down:
 745     {
 746       itemID += mImpl->mNumberOfColumns;
 747       if( itemID >= maxItems )
 748       {
 749         itemID = loopEnabled ? 0 : itemID - mImpl->mNumberOfColumns;
 750       }
 751       break;
 752     }
 753   }
 754   return itemID;
 755 }
 756
 757 GridLayout::GridLayout()
 758 : mImpl(NULL)
 759 {
 760   mImpl = new Impl();
 761 }
 762
 763 } // namespace Toolkit
 764
 765 } // namespace Dali