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