Update doxygen comments
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / public-api / controls / scrollable / scroll-view / scroll-view.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/scroll-view/scroll-view.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali/integration-api/debug.h>
23
24 // INTERNAL INCLUDES
25 #include <dali-toolkit/public-api/controls/scrollable/scrollable.h>
26 #include <dali-toolkit/internal/controls/scrollable/scroll-view/scroll-view-impl.h>
27
28 using namespace Dali;
29
30 namespace Dali
31 {
32
33 namespace Toolkit
34 {
35
36 ///////////////////////////////////////////////////////////////////////////////////////////////////
37 // RulerDomain
38 ///////////////////////////////////////////////////////////////////////////////////////////////////
39
40 RulerDomain::RulerDomain(float min, float max, bool enabled)
41 : min(min),
42   max(max),
43   enabled(enabled)
44 {
45 }
46
47 float RulerDomain::Clamp(float x, float length, float scale) const
48 {
49   ClampState clamped;
50
51   return Clamp(x, length, scale, clamped);
52 }
53
54 float RulerDomain::Clamp(float x, float length, float scale, ClampState &clamped) const
55 {
56   if(!enabled)
57   {
58     clamped = NotClamped;
59     return x;
60   }
61
62   const float minExtent = min * scale;
63   const float maxExtent = max * scale - length;
64   if(x < minExtent)
65   {
66     clamped = ClampedToMin;
67     return minExtent;
68   }
69   else if(x > maxExtent)
70   {
71     clamped = ClampedToMax;
72     return maxExtent;
73   }
74
75   clamped = NotClamped;
76   return x;
77 }
78
79 float RulerDomain::GetSize() const
80 {
81   return max-min;
82 }
83
84 ///////////////////////////////////////////////////////////////////////////////////////////////////
85 // Ruler
86 ///////////////////////////////////////////////////////////////////////////////////////////////////
87
88 Ruler::Ruler()
89 : mType(Free),
90   mEnabled(true),
91   mDomain(RulerDomain(0.0f,1.0f,false))
92 {
93 }
94
95 Ruler::~Ruler()
96 {
97 }
98
99 Ruler::RulerType Ruler::GetType() const
100 {
101   return mType;
102 }
103
104 bool Ruler::IsEnabled() const
105 {
106   return mEnabled;
107 }
108
109 void Ruler::Enable()
110 {
111   mEnabled = true;
112 }
113
114 void Ruler::Disable()
115 {
116   mEnabled = false;
117 }
118
119 void Ruler::SetDomain(RulerDomain domain)
120 {
121   mDomain = domain;
122 }
123
124 const RulerDomain &Ruler::GetDomain() const
125 {
126   return mDomain;
127 }
128
129 void Ruler::DisableDomain()
130 {
131   mDomain = RulerDomain(0.0f,1.0f,false);
132 }
133
134 float Ruler::Clamp(float x, float length, float scale) const
135 {
136   return mDomain.Clamp(x, length, scale);
137 }
138
139 float Ruler::Clamp(float x, float length, float scale, ClampState &clamped) const
140 {
141   return mDomain.Clamp(x, length, scale, clamped);
142 }
143
144 float Ruler::SnapAndClamp(float x, float bias, float length, float scale) const
145 {
146   return Clamp(Snap(x, bias), length, scale);
147 }
148
149 float Ruler::SnapAndClamp(float x, float bias, float length, float scale, ClampState &clamped) const
150 {
151   return Clamp(Snap(x, bias), length, scale, clamped);
152 }
153
154 ///////////////////////////////////////////////////////////////////////////////////////////////////
155 // DefaultRuler
156 ///////////////////////////////////////////////////////////////////////////////////////////////////
157
158 DefaultRuler::DefaultRuler()
159 {
160   mType = Free;
161 }
162
163 float DefaultRuler::Snap(float x, float bias) const
164 {
165   return x;
166 }
167
168 float DefaultRuler::GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const
169 {
170   volume = 0;
171   return 0.0f;
172 }
173
174 unsigned int DefaultRuler::GetPageFromPosition(float position, bool wrap) const
175 {
176   return 0;
177 }
178
179 unsigned int DefaultRuler::GetTotalPages() const
180 {
181   return 1;
182 }
183
184 ///////////////////////////////////////////////////////////////////////////////////////////////////
185 // FixedRuler
186 ///////////////////////////////////////////////////////////////////////////////////////////////////
187
188 FixedRuler::FixedRuler(float spacing)
189 : mSpacing(spacing)
190 {
191   if(fabsf(mSpacing) <= Math::MACHINE_EPSILON_1)
192   {
193     DALI_LOG_ERROR( "Page spacing too small (%f).\n", double(spacing) );
194     mSpacing = spacing >= 0.0f ? Math::MACHINE_EPSILON_1 : -Math::MACHINE_EPSILON_1;
195   }
196   mType = Fixed;
197 }
198
199 float FixedRuler::Snap(float x, float bias) const
200 {
201   return floor(x / mSpacing + bias) * mSpacing;
202 }
203
204 float FixedRuler::GetPositionFromPage(unsigned int page, unsigned int &volume, bool wrap) const
205 {
206   float position = mDomain.min;
207
208   volume = 0;
209
210   // spacing must be present.
211   if( mEnabled )
212   {
213     unsigned int column = page;
214
215     // In carry mode, a volume (carry) is produced when page exceeds limit within domain
216     if(wrap)
217     {
218       unsigned int pagesPerVolume = mDomain.GetSize() / mSpacing;
219       if(pagesPerVolume>0)
220       {
221         column += pagesPerVolume;
222         column %= pagesPerVolume;
223         volume = page/pagesPerVolume;
224       }
225     }
226
227     position = mDomain.min + column * mSpacing;
228   }
229   else  // Domain (or Spacing) is not present, carry page to volume.
230   {
231     if(wrap)
232     {
233       volume = page;
234     }
235   }
236
237   return position;
238 }
239
240 unsigned int FixedRuler::GetPageFromPosition(float position, bool wrap) const
241 {
242   unsigned int page = 0;
243
244   // spacing must be present.
245   if( mEnabled )
246   {
247     if( wrap )
248     {
249       position = WrapInDomain(position, mDomain.min, mDomain.max);
250     }
251     page = std::max(static_cast<double>(0.0f), floor((position - mDomain.min) / mSpacing + 0.5f));
252
253     if(wrap)
254     {
255       unsigned int pagesPerVolume = mDomain.GetSize() / mSpacing;
256       // Defensive check to avoid a divide by zero below when the ruler is in an invalid state (entire domain smaller than spacing between pages of it):
257       if(pagesPerVolume < 1u)
258       {
259         pagesPerVolume = 1u;
260         DALI_LOG_ERROR("Ruler domain(%f) is smaller than its spacing(%f).\n", mDomain.GetSize() * 1.0, mSpacing * 1.0 );
261       }
262       page %= pagesPerVolume;
263     }
264   }
265
266   return page;
267 }
268
269 unsigned int FixedRuler::GetTotalPages() const
270 {
271   unsigned int pagesPerVolume = 1;
272
273   // spacing must be present.
274   if( mEnabled )
275   {
276     pagesPerVolume = mDomain.GetSize() / mSpacing;
277   }
278
279   return pagesPerVolume;
280 }
281
282 ///////////////////////////////////////////////////////////////////////////////////////////////////
283 // ScrollView
284 ///////////////////////////////////////////////////////////////////////////////////////////////////
285
286 ScrollView::ScrollView()
287 {
288 }
289
290 ScrollView::ScrollView(Internal::ScrollView& implementation)
291 : Scrollable(implementation)
292 {
293 }
294
295 ScrollView::ScrollView( Dali::Internal::CustomActor* internal )
296 : Scrollable( internal )
297 {
298   VerifyCustomActorPointer<Internal::ScrollView>(internal);
299 }
300
301 ScrollView::ScrollView( const ScrollView& handle )
302 : Scrollable( handle )
303 {
304 }
305
306 ScrollView& ScrollView::operator=( const ScrollView& handle )
307 {
308   if( &handle != this )
309   {
310     Control::operator=( handle );
311   }
312   return *this;
313 }
314
315 ScrollView ScrollView::New()
316 {
317   return Internal::ScrollView::New();
318 }
319
320 ScrollView::~ScrollView()
321 {
322 }
323
324 ScrollView ScrollView::DownCast( BaseHandle handle )
325 {
326   return Control::DownCast<ScrollView, Internal::ScrollView>(handle);
327 }
328
329 AlphaFunction ScrollView::GetScrollSnapAlphaFunction() const
330 {
331   return GetImpl(*this).GetScrollSnapAlphaFunction();
332 }
333
334 void ScrollView::SetScrollSnapAlphaFunction(AlphaFunction alpha)
335 {
336   GetImpl(*this).SetScrollSnapAlphaFunction(alpha);
337 }
338
339 AlphaFunction ScrollView::GetScrollFlickAlphaFunction() const
340 {
341   return GetImpl(*this).GetScrollFlickAlphaFunction();
342 }
343
344 void ScrollView::SetScrollFlickAlphaFunction(AlphaFunction alpha)
345 {
346   GetImpl(*this).SetScrollFlickAlphaFunction(alpha);
347 }
348
349 float ScrollView::GetScrollSnapDuration() const
350 {
351   return GetImpl(*this).GetScrollSnapDuration();
352 }
353
354 void ScrollView::SetScrollSnapDuration(float time)
355 {
356   GetImpl(*this).SetScrollSnapDuration(time);
357 }
358
359 float ScrollView::GetScrollFlickDuration() const
360 {
361   return GetImpl(*this).GetScrollFlickDuration();
362 }
363
364 void ScrollView::SetScrollFlickDuration(float time)
365 {
366   GetImpl(*this).SetScrollFlickDuration(time);
367 }
368
369 void ScrollView::SetRulerX(RulerPtr ruler)
370 {
371   GetImpl(*this).SetRulerX(ruler);
372 }
373
374 void ScrollView::SetRulerY(RulerPtr ruler)
375 {
376   GetImpl(*this).SetRulerY(ruler);
377 }
378
379 void ScrollView::SetScrollSensitive(bool sensitive)
380 {
381   GetImpl(*this).SetScrollSensitive(sensitive);
382 }
383
384 void ScrollView::SetMaxOvershoot(float overshootX, float overshootY)
385 {
386   GetImpl(*this).SetMaxOvershoot(overshootX, overshootY);
387 }
388
389 void ScrollView::SetSnapOvershootAlphaFunction(AlphaFunction alpha)
390 {
391   GetImpl(*this).SetSnapOvershootAlphaFunction(alpha);
392 }
393
394 void ScrollView::SetSnapOvershootDuration(float duration)
395 {
396   GetImpl(*this).SetSnapOvershootDuration(duration);
397 }
398
399 void ScrollView::SetActorAutoSnap(bool enable)
400 {
401   GetImpl(*this).SetActorAutoSnap(enable);
402 }
403
404 void ScrollView::SetWrapMode(bool enable)
405 {
406   GetImpl(*this).SetWrapMode(enable);
407 }
408
409 int ScrollView::GetScrollUpdateDistance() const
410 {
411   return GetImpl(*this).GetScrollUpdateDistance();
412 }
413
414 void ScrollView::SetScrollUpdateDistance(int distance)
415 {
416   GetImpl(*this).SetScrollUpdateDistance(distance);
417 }
418
419 bool ScrollView::GetAxisAutoLock() const
420 {
421   return GetImpl(*this).GetAxisAutoLock();
422 }
423
424 void ScrollView::SetAxisAutoLock(bool enable)
425 {
426   GetImpl(*this).SetAxisAutoLock(enable);
427 }
428
429 float ScrollView::GetAxisAutoLockGradient() const
430 {
431   return GetImpl(*this).GetAxisAutoLockGradient();
432 }
433
434 void ScrollView::SetAxisAutoLockGradient(float gradient)
435 {
436   GetImpl(*this).SetAxisAutoLockGradient(gradient);
437 }
438
439 float ScrollView::GetFrictionCoefficient() const
440 {
441   return GetImpl(*this).GetFrictionCoefficient();
442 }
443
444 void ScrollView::SetFrictionCoefficient(float friction)
445 {
446   GetImpl(*this).SetFrictionCoefficient(friction);
447 }
448
449 float ScrollView::GetFlickSpeedCoefficient() const
450 {
451   return GetImpl(*this).GetFlickSpeedCoefficient();
452 }
453
454 void ScrollView::SetFlickSpeedCoefficient(float speed)
455 {
456   GetImpl(*this).SetFlickSpeedCoefficient(speed);
457 }
458
459 Vector2 ScrollView::GetMinimumDistanceForFlick() const
460 {
461   return GetImpl(*this).GetMinimumDistanceForFlick();
462 }
463
464 void ScrollView::SetMinimumDistanceForFlick( const Vector2& distance )
465 {
466   GetImpl(*this).SetMinimumDistanceForFlick(distance);
467 }
468
469 float ScrollView::GetMinimumSpeedForFlick() const
470 {
471   return GetImpl(*this).GetMinimumSpeedForFlick();
472 }
473
474 void ScrollView::SetMinimumSpeedForFlick( float speed )
475 {
476   GetImpl(*this).SetMinimumSpeedForFlick(speed);
477 }
478
479 float ScrollView::GetMaxFlickSpeed() const
480 {
481   return GetImpl(*this).GetMaxFlickSpeed();
482 }
483
484 void ScrollView::SetMaxFlickSpeed(float speed)
485 {
486   GetImpl(*this).SetMaxFlickSpeed(speed);
487 }
488
489 Vector2 ScrollView::GetWheelScrollDistanceStep() const
490 {
491   return GetImpl(*this).GetWheelScrollDistanceStep();
492 }
493
494 void ScrollView::SetWheelScrollDistanceStep(Vector2 step)
495 {
496   GetImpl(*this).SetWheelScrollDistanceStep(step);
497 }
498
499 Vector2 ScrollView::GetCurrentScrollPosition() const
500 {
501   return GetImpl(*this).GetCurrentScrollPosition();
502 }
503
504 unsigned int ScrollView::GetCurrentPage() const
505 {
506   return GetImpl(*this).GetCurrentPage();
507 }
508
509 void ScrollView::ScrollTo(const Vector2 &position)
510 {
511   GetImpl(*this).ScrollTo(position);
512 }
513
514 void ScrollView::ScrollTo(const Vector2 &position, float duration)
515 {
516   GetImpl(*this).ScrollTo(position, duration);
517 }
518
519 void ScrollView::ScrollTo(const Vector2 &position, float duration, AlphaFunction alpha)
520 {
521   GetImpl(*this).ScrollTo(position, duration, alpha);
522 }
523
524 void ScrollView::ScrollTo(const Vector2 &position, float duration,
525                           DirectionBias horizontalBias, DirectionBias verticalBias)
526 {
527   GetImpl(*this).ScrollTo(position, duration, horizontalBias, verticalBias);
528 }
529
530 void ScrollView::ScrollTo(const Vector2 &position, float duration, AlphaFunction alpha,
531                           DirectionBias horizontalBias, DirectionBias verticalBias)
532 {
533   GetImpl(*this).ScrollTo(position, duration, alpha, horizontalBias, verticalBias);
534 }
535
536 void ScrollView::ScrollTo(unsigned int page)
537 {
538   GetImpl(*this).ScrollTo(page);
539 }
540
541 void ScrollView::ScrollTo(unsigned int page, float duration)
542 {
543   GetImpl(*this).ScrollTo(page, duration);
544 }
545
546 void ScrollView::ScrollTo(unsigned int page, float duration, DirectionBias bias)
547 {
548   GetImpl(*this).ScrollTo(page, duration, bias);
549 }
550
551 void ScrollView::ScrollTo(Actor &actor)
552 {
553   GetImpl(*this).ScrollTo(actor);
554 }
555
556 void ScrollView::ScrollTo(Actor &actor, float duration)
557 {
558   GetImpl(*this).ScrollTo(actor, duration);
559 }
560
561 bool ScrollView::ScrollToSnapPoint()
562 {
563   return GetImpl(*this).ScrollToSnapPoint();
564 }
565
566 void ScrollView::ApplyConstraintToChildren(Constraint constraint)
567 {
568   GetImpl(*this).ApplyConstraintToChildren(constraint);
569 }
570
571 void ScrollView::RemoveConstraintsFromChildren()
572 {
573   GetImpl(*this).RemoveConstraintsFromChildren();
574 }
575
576 void ScrollView::ApplyEffect(ScrollViewEffect effect)
577 {
578   GetImpl(*this).ApplyEffect(effect);
579 }
580
581 void ScrollView::RemoveEffect(ScrollViewEffect effect)
582 {
583   GetImpl(*this).RemoveEffect(effect);
584 }
585
586 void ScrollView::RemoveAllEffects()
587 {
588   GetImpl(*this).RemoveAllEffects();
589 }
590
591 void ScrollView::BindActor(Actor child)
592 {
593   GetImpl(*this).BindActor(child);
594 }
595
596 void ScrollView::UnbindActor(Actor child)
597 {
598   GetImpl(*this).UnbindActor(child);
599 }
600
601 ScrollView::SnapStartedSignalType& ScrollView::SnapStartedSignal()
602 {
603   return GetImpl(*this).SnapStartedSignal();
604 }
605
606 void ScrollView::SetScrollingDirection( Radian direction, Radian threshold )
607 {
608   GetImpl(*this).SetScrollingDirection( direction, threshold );
609 }
610
611 void ScrollView::RemoveScrollingDirection( Radian direction )
612 {
613   GetImpl(*this).RemoveScrollingDirection( direction );
614 }
615
616 } // namespace Toolkit
617
618 } // namespace Dali