Dali 3D User Interface Engine
scroll-view.cpp
Go to the documentation of this file.
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
20 
21 // EXTERNAL INCLUDES
23 
24 // INTERNAL INCLUDES
27 
28 using namespace Dali;
29 
30 namespace Dali
31 {
32 
33 namespace Toolkit
34 {
35 
37 // RulerDomain
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 
85 // Ruler
87 
89 : mType(Free),
90  mEnabled(true),
91  mDomain(RulerDomain(0.0f,1.0f,false))
92 {
93 }
94 
96 {
97 }
98 
100 {
101  return mType;
102 }
103 
104 bool Ruler::IsEnabled() const
105 {
106  return mEnabled;
107 }
108 
110 {
111  mEnabled = true;
112 }
113 
115 {
116  mEnabled = false;
117 }
118 
120 {
121  mDomain = domain;
122 }
123 
125 {
126  return mDomain;
127 }
128 
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 
155 // DefaultRuler
157 
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 
185 // FixedRuler
187 
189 : mSpacing(spacing)
190 {
191  if(fabsf(mSpacing) <= Math::MACHINE_EPSILON_1)
192  {
193  DALI_LOG_ERROR( "Page spacing too small (%f).", double(spacing) );
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).", 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 
283 // ScrollView
285 
287 {
288 }
289 
291 : Scrollable(implementation)
292 {
293 }
294 
296 : Scrollable( internal )
297 {
298  VerifyCustomActorPointer<Internal::ScrollView>(internal);
299 }
300 
302 : Scrollable( handle )
303 {
304 }
305 
307 {
308  if( &handle != this )
309  {
310  Control::operator=( handle );
311  }
312  return *this;
313 }
314 
316 {
317  return Internal::ScrollView::New();
318 }
319 
321 {
322 }
323 
325 {
326  return Control::DownCast<ScrollView, Internal::ScrollView>(handle);
327 }
328 
330 {
331  return GetImpl(*this).GetScrollSnapAlphaFunction();
332 }
333 
335 {
336  GetImpl(*this).SetScrollSnapAlphaFunction(alpha);
337 }
338 
340 {
341  return GetImpl(*this).GetScrollFlickAlphaFunction();
342 }
343 
345 {
346  GetImpl(*this).SetScrollFlickAlphaFunction(alpha);
347 }
348 
350 {
351  return GetImpl(*this).GetScrollSnapDuration();
352 }
353 
355 {
356  GetImpl(*this).SetScrollSnapDuration(time);
357 }
358 
360 {
361  return GetImpl(*this).GetScrollFlickDuration();
362 }
363 
365 {
366  GetImpl(*this).SetScrollFlickDuration(time);
367 }
368 
370 {
371  GetImpl(*this).SetRulerX(ruler);
372 }
373 
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 
390 {
391  GetImpl(*this).SetSnapOvershootAlphaFunction(alpha);
392 }
393 
395 {
396  GetImpl(*this).SetSnapOvershootDuration(duration);
397 }
398 
400 {
401  GetImpl(*this).SetActorAutoSnap(enable);
402 }
403 
404 void ScrollView::SetWrapMode(bool enable)
405 {
406  GetImpl(*this).SetWrapMode(enable);
407 }
408 
410 {
411  return GetImpl(*this).GetScrollUpdateDistance();
412 }
413 
415 {
416  GetImpl(*this).SetScrollUpdateDistance(distance);
417 }
418 
420 {
421  return GetImpl(*this).GetAxisAutoLock();
422 }
423 
425 {
426  GetImpl(*this).SetAxisAutoLock(enable);
427 }
428 
430 {
431  return GetImpl(*this).GetAxisAutoLockGradient();
432 }
433 
435 {
436  GetImpl(*this).SetAxisAutoLockGradient(gradient);
437 }
438 
440 {
441  return GetImpl(*this).GetFrictionCoefficient();
442 }
443 
445 {
446  GetImpl(*this).SetFrictionCoefficient(friction);
447 }
448 
450 {
451  return GetImpl(*this).GetFlickSpeedCoefficient();
452 }
453 
455 {
456  GetImpl(*this).SetFlickSpeedCoefficient(speed);
457 }
458 
460 {
461  return GetImpl(*this).GetMinimumDistanceForFlick();
462 }
463 
465 {
466  GetImpl(*this).SetMinimumDistanceForFlick(distance);
467 }
468 
470 {
471  return GetImpl(*this).GetMinimumSpeedForFlick();
472 }
473 
475 {
476  GetImpl(*this).SetMinimumSpeedForFlick(speed);
477 }
478 
480 {
481  return GetImpl(*this).GetMaxFlickSpeed();
482 }
483 
485 {
486  GetImpl(*this).SetMaxFlickSpeed(speed);
487 }
488 
490 {
491  return GetImpl(*this).GetWheelScrollDistanceStep();
492 }
493 
495 {
496  GetImpl(*this).SetWheelScrollDistanceStep(step);
497 }
498 
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 
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 
562 {
563  return GetImpl(*this).ScrollToSnapPoint();
564 }
565 
567 {
568  GetImpl(*this).ApplyConstraintToChildren(constraint);
569 }
570 
572 {
573  GetImpl(*this).RemoveConstraintsFromChildren();
574 }
575 
577 {
578  GetImpl(*this).ApplyEffect(effect);
579 }
580 
582 {
583  GetImpl(*this).RemoveEffect(effect);
584 }
585 
587 {
588  GetImpl(*this).RemoveAllEffects();
589 }
590 
592 {
593  GetImpl(*this).BindActor(child);
594 }
595 
597 {
598  GetImpl(*this).UnbindActor(child);
599 }
600 
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 
612 {
613  GetImpl(*this).RemoveScrollingDirection( direction );
614 }
615 
616 } // namespace Toolkit
617 
618 } // namespace Dali
Dali Docs Home
Read more about Dali