1 /* Copyright (c) 2021 Samsung Electronics Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
17 using Tizen.NUI.BaseComponents;
18 using System.Collections.Generic;
19 using System.ComponentModel;
20 using System.Diagnostics;
21 using System.Runtime.InteropServices;
22 using Tizen.NUI.Accessibility;
24 namespace Tizen.NUI.Components
27 /// ScrollEventArgs is a class to record scroll event arguments which will sent to user.
29 /// <since_tizen> 8 </since_tizen>
30 public class ScrollEventArgs : EventArgs
32 private Position position;
33 private Position scrollPosition;
36 /// Default constructor.
38 /// <param name="position">Current container position</param>
39 /// <since_tizen> 8 </since_tizen>
40 public ScrollEventArgs(Position position)
42 this.position = position;
43 this.scrollPosition = new Position(-position);
47 /// Current position of ContentContainer.
49 /// <since_tizen> 8 </since_tizen>
50 public Position Position
58 /// Current scroll position of scrollableBase pan.
59 /// This is the position in the opposite direction to the current position of ContentContainer.
61 [EditorBrowsable(EditorBrowsableState.Never)]
62 public Position ScrollPosition
66 return scrollPosition;
72 /// ScrollOutofBoundEventArgs is to record scroll out-of-bound event arguments which will be sent to user.
74 [EditorBrowsable(EditorBrowsableState.Never)]
75 public class ScrollOutOfBoundEventArgs : EventArgs
78 /// The direction to be touched.
80 [EditorBrowsable(EditorBrowsableState.Never)]
86 [EditorBrowsable(EditorBrowsableState.Never)]
92 [EditorBrowsable(EditorBrowsableState.Never)]
98 [EditorBrowsable(EditorBrowsableState.Never)]
104 [EditorBrowsable(EditorBrowsableState.Never)]
111 /// <param name="direction">Current pan direction</param>
112 /// <param name="displacement">Current total displacement</param>
113 [EditorBrowsable(EditorBrowsableState.Never)]
114 public ScrollOutOfBoundEventArgs(Direction direction, float displacement)
116 PanDirection = direction;
117 Displacement = displacement;
121 /// Current pan direction of ContentContainer.
123 [EditorBrowsable(EditorBrowsableState.Never)]
124 public Direction PanDirection
130 /// Current total displacement of ContentContainer.
131 /// if its value is greater than 0, it is at the top/left;
132 /// if less than 0, it is at the bottom/right.
134 [EditorBrowsable(EditorBrowsableState.Never)]
135 public float Displacement
142 /// This class provides a View that can scroll a single View with a layout. This View can be a nest of Views.
144 /// <since_tizen> 8 </since_tizen>
145 public class ScrollableBase : Control
147 static bool LayoutDebugScrollableBase = false; // Debug flag
148 private Direction mScrollingDirection = Direction.Vertical;
149 private bool mScrollEnabled = true;
150 private int mScrollDuration = 125;
151 private int mPageWidth = 0;
152 private float mPageFlickThreshold = 0.4f;
153 private float mScrollingEventThreshold = 0.001f;
155 private class ScrollableBaseCustomLayout : AbsoluteLayout
157 protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
159 MeasuredSize.StateType childWidthState = MeasuredSize.StateType.MeasuredSizeOK;
160 MeasuredSize.StateType childHeightState = MeasuredSize.StateType.MeasuredSizeOK;
162 Direction scrollingDirection = Direction.Vertical;
163 ScrollableBase scrollableBase = this.Owner as ScrollableBase;
164 if (scrollableBase != null)
166 scrollingDirection = scrollableBase.ScrollingDirection;
169 float totalWidth = 0.0f;
170 float totalHeight = 0.0f;
172 // measure child, should be a single scrolling child
173 foreach (LayoutItem childLayout in LayoutChildren)
175 if (childLayout != null && childLayout.Owner.Name == "ContentContainer")
178 // Use an Unspecified MeasureSpecification mode so scrolling child is not restricted to it's parents size in Height (for vertical scrolling)
179 // or Width for horizontal scrolling
180 if (scrollingDirection == Direction.Vertical)
182 MeasureSpecification unrestrictedMeasureSpec = new MeasureSpecification(heightMeasureSpec.Size, MeasureSpecification.ModeType.Unspecified);
183 MeasureChildWithMargins(childLayout, widthMeasureSpec, new LayoutLength(0), unrestrictedMeasureSpec, new LayoutLength(0)); // Height unrestricted by parent
187 MeasureSpecification unrestrictedMeasureSpec = new MeasureSpecification(widthMeasureSpec.Size, MeasureSpecification.ModeType.Unspecified);
188 MeasureChildWithMargins(childLayout, unrestrictedMeasureSpec, new LayoutLength(0), heightMeasureSpec, new LayoutLength(0)); // Width unrestricted by parent
191 totalWidth = (childLayout.MeasuredWidth.Size + (childLayout.Padding.Start + childLayout.Padding.End)).AsDecimal();
192 totalHeight = (childLayout.MeasuredHeight.Size + (childLayout.Padding.Top + childLayout.Padding.Bottom)).AsDecimal();
194 if (childLayout.MeasuredWidth.State == MeasuredSize.StateType.MeasuredSizeTooSmall)
196 childWidthState = MeasuredSize.StateType.MeasuredSizeTooSmall;
198 if (childLayout.MeasuredHeight.State == MeasuredSize.StateType.MeasuredSizeTooSmall)
200 childHeightState = MeasuredSize.StateType.MeasuredSizeTooSmall;
205 MeasuredSize widthSizeAndState = ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK);
206 MeasuredSize heightSizeAndState = ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK);
207 totalWidth = widthSizeAndState.Size.AsDecimal();
208 totalHeight = heightSizeAndState.Size.AsDecimal();
210 // Ensure layout respects it's given minimum size
211 totalWidth = Math.Max(totalWidth, SuggestedMinimumWidth.AsDecimal());
212 totalHeight = Math.Max(totalHeight, SuggestedMinimumHeight.AsDecimal());
214 widthSizeAndState.State = childWidthState;
215 heightSizeAndState.State = childHeightState;
217 SetMeasuredDimensions(ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, childWidthState),
218 ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, childHeightState));
220 // Size of ScrollableBase is changed. Change Page width too.
221 if (scrollableBase != null)
223 scrollableBase.mPageWidth = (int)MeasuredWidth.Size.AsRoundedValue();
224 scrollableBase.OnScrollingChildRelayout(null, null);
227 } // ScrollableBaseCustomLayout
230 /// The direction axis to scroll.
232 /// <since_tizen> 8 </since_tizen>
233 public enum Direction
238 /// <since_tizen> 8 </since_tizen>
244 /// <since_tizen> 8 </since_tizen>
249 /// Scrolling direction mode.
250 /// Default is Vertical scrolling.
252 /// <since_tizen> 8 </since_tizen>
253 public Direction ScrollingDirection
257 return mScrollingDirection;
261 if (value != mScrollingDirection)
263 //Reset scroll position and stop scroll animation
266 mScrollingDirection = value;
267 mPanGestureDetector.ClearAngles();
268 mPanGestureDetector.AddDirection(value == Direction.Horizontal ?
269 PanGestureDetector.DirectionHorizontal : PanGestureDetector.DirectionVertical);
271 ContentContainer.WidthSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.MatchParent : LayoutParamPolicies.WrapContent;
272 ContentContainer.HeightSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.WrapContent : LayoutParamPolicies.MatchParent;
279 /// Enable or disable scrolling.
281 /// <since_tizen> 8 </since_tizen>
282 public bool ScrollEnabled
286 return mScrollEnabled;
290 if (value != mScrollEnabled)
292 mScrollEnabled = value;
295 mPanGestureDetector.Detected += OnPanGestureDetected;
299 mPanGestureDetector.Detected -= OnPanGestureDetected;
306 /// Gets scrollable status.
308 [EditorBrowsable(EditorBrowsableState.Never)]
309 protected override bool AccessibilityIsScrollable()
315 /// Pages mode, enables moving to the next or return to current page depending on pan displacement.
316 /// Default is false.
318 /// <since_tizen> 8 </since_tizen>
319 public bool SnapToPage { set; get; } = false;
322 /// Get current page.
323 /// Working property with SnapToPage property.
325 /// <since_tizen> 8 </since_tizen>
326 public int CurrentPage { get; private set; } = 0;
329 /// Duration of scroll animation.
330 /// Default value is 125ms.
332 /// <since_tizen> 8 </since_tizen>
333 public int ScrollDuration
337 mScrollDuration = value >= 0 ? value : mScrollDuration;
341 return mScrollDuration;
346 /// Scroll Available area.
348 /// <since_tizen> 8 </since_tizen>
349 public Vector2 ScrollAvailableArea { set; get; }
352 /// An event emitted when user starts dragging ScrollableBase, user can subscribe or unsubscribe to this event handler.<br />
354 /// <since_tizen> 8 </since_tizen>
355 public event EventHandler<ScrollEventArgs> ScrollDragStarted;
358 /// An event emitted when user stops dragging ScrollableBase, user can subscribe or unsubscribe to this event handler.<br />
360 /// <since_tizen> 8 </since_tizen>
361 public event EventHandler<ScrollEventArgs> ScrollDragEnded;
364 /// An event emitted when the scrolling slide animation starts, user can subscribe or unsubscribe to this event handler.<br />
366 /// <since_tizen> 8 </since_tizen>
367 public event EventHandler<ScrollEventArgs> ScrollAnimationStarted;
370 /// An event emitted when the scrolling slide animation ends, user can subscribe or unsubscribe to this event handler.<br />
372 /// <since_tizen> 8 </since_tizen>
373 public event EventHandler<ScrollEventArgs> ScrollAnimationEnded;
376 /// An event emitted when scrolling, user can subscribe or unsubscribe to this event handler.<br />
378 /// <since_tizen> 8 </since_tizen>
379 public event EventHandler<ScrollEventArgs> Scrolling;
382 /// An event emitted when scrolling out of bound, user can subscribe or unsubscribe to this event handler.<br />
384 [EditorBrowsable(EditorBrowsableState.Never)]
385 public event EventHandler<ScrollOutOfBoundEventArgs> ScrollOutOfBound;
388 /// Scrollbar for ScrollableBase.
390 /// <since_tizen> 8 </since_tizen>
391 public ScrollbarBase Scrollbar
401 base.Remove(scrollBar);
405 if (scrollBar != null)
407 scrollBar.Name = "ScrollBar";
425 /// Always hide Scrollbar.
427 /// <since_tizen> 8 </since_tizen>
428 public bool HideScrollbar
432 return hideScrollbar;
436 hideScrollbar = value;
453 /// Container which has content of ScrollableBase.
455 /// <since_tizen> 8 </since_tizen>
456 public View ContentContainer { get; private set; }
459 /// Set the layout on this View. Replaces any existing Layout.
461 /// <since_tizen> 8 </since_tizen>
462 public new LayoutItem Layout
466 return ContentContainer.Layout;
470 ContentContainer.Layout = value;
475 /// List of children of Container.
477 /// <since_tizen> 8 </since_tizen>
478 public new List<View> Children
482 return ContentContainer.Children;
487 /// Deceleration rate of scrolling by finger.
488 /// Rate should be bigger than 0 and smaller than 1.
489 /// Default value is 0.998f;
491 /// <since_tizen> 8 </since_tizen>
492 public float DecelerationRate
496 return decelerationRate;
500 decelerationRate = (value < 1 && value > 0) ? value : decelerationRate;
501 logValueOfDeceleration = (float)Math.Log(value);
506 /// Threshold not to go infinite at the end of scrolling animation.
508 [EditorBrowsable(EditorBrowsableState.Never)]
509 public float DecelerationThreshold { get; set; } = 0.1f;
512 /// Scrolling event will be thrown when this amount of scroll position is changed.
513 /// If this threshold becomes smaller, the tracking detail increases but the scrolling range that can be tracked becomes smaller.
514 /// If large sized ContentContainer is required, please use larger threshold value.
515 /// Default ScrollingEventThreshold value is 0.001f.
517 [EditorBrowsable(EditorBrowsableState.Never)]
518 public float ScrollingEventThreshold
522 return mScrollingEventThreshold;
526 if (mScrollingEventThreshold != value && value > 0)
528 ContentContainer.RemovePropertyNotification(propertyNotification);
529 propertyNotification = ContentContainer.AddPropertyNotification("position", PropertyCondition.Step(value));
530 propertyNotification.Notified += OnPropertyChanged;
531 mScrollingEventThreshold = value;
537 /// Page will be changed when velocity of panning is over threshold.
538 /// The unit of threshold is pixel per millisecond.
540 /// <since_tizen> 8 </since_tizen>
541 public float PageFlickThreshold
545 return mPageFlickThreshold;
549 mPageFlickThreshold = value >= 0f ? value : mPageFlickThreshold;
554 /// Padding for the ScrollableBase
556 [EditorBrowsable(EditorBrowsableState.Never)]
557 public new Extents Padding
561 return ContentContainer.Padding;
565 ContentContainer.Padding = value;
570 /// Alphafunction for scroll animation.
572 [EditorBrowsable(EditorBrowsableState.Never)]
573 public AlphaFunction ScrollAlphaFunction { get; set; } = new AlphaFunction(AlphaFunction.BuiltinFunctions.Linear);
575 private bool hideScrollbar = true;
576 private float maxScrollDistance;
577 private float childTargetPosition = 0.0f;
578 private PanGestureDetector mPanGestureDetector;
579 private ScrollbarBase scrollBar;
580 private bool scrolling = false;
581 private float ratioOfScreenWidthToCompleteScroll = 0.5f;
582 private float totalDisplacementForPan = 0.0f;
583 private Size previousContainerSize = new Size();
584 private Size previousSize = new Size();
585 private PropertyNotification propertyNotification;
586 private float noticeAnimationEndBeforePosition = 0.0f;
587 private bool readyToNotice = false;
590 /// Notice before animation is finished.
592 [EditorBrowsable(EditorBrowsableState.Never)]
593 // Let's consider more whether this needs to be set as protected.
594 public float NoticeAnimationEndBeforePosition
596 get => noticeAnimationEndBeforePosition;
597 set => noticeAnimationEndBeforePosition = value;
600 // Let's consider more whether this needs to be set as protected.
601 private float finalTargetPosition;
603 private Animation scrollAnimation;
604 // Declare user alpha function delegate
605 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
606 private delegate float UserAlphaFunctionDelegate(float progress);
607 private UserAlphaFunctionDelegate customScrollAlphaFunction;
608 private float velocityOfLastPan = 0.0f;
609 private float panAnimationDuration = 0.0f;
610 private float panAnimationDelta = 0.0f;
611 private float logValueOfDeceleration = 0.0f;
612 private float decelerationRate = 0.0f;
614 private View topOverShootingShadowView;
615 private View bottomOverShootingShadowView;
616 private View leftOverShootingShadowView;
617 private View rightOverShootingShadowView;
618 private const int overShootingShadowScaleHeightLimit = 64 * 3;
619 private const int overShootingShadowAnimationDuration = 300;
620 private Animation overShootingShadowAnimation;
621 private bool isOverShootingShadowShown = false;
622 private float startShowShadowDisplacement;
625 /// Default Constructor
627 /// <since_tizen> 8 </since_tizen>
628 public ScrollableBase() : base()
630 DecelerationRate = 0.998f;
632 base.Layout = new ScrollableBaseCustomLayout();
633 mPanGestureDetector = new PanGestureDetector();
634 mPanGestureDetector.Attach(this);
635 mPanGestureDetector.AddDirection(PanGestureDetector.DirectionVertical);
636 if (mPanGestureDetector.GetMaximumTouchesRequired() < 2) mPanGestureDetector.SetMaximumTouchesRequired(2);
637 mPanGestureDetector.Detected += OnPanGestureDetected;
639 ClippingMode = ClippingModeType.ClipToBoundingBox;
641 //Default Scrolling child
642 ContentContainer = new View()
644 Name = "ContentContainer",
645 WidthSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.MatchParent : LayoutParamPolicies.WrapContent,
646 HeightSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.WrapContent : LayoutParamPolicies.MatchParent,
648 ContentContainer.Relayout += OnScrollingChildRelayout;
649 propertyNotification = ContentContainer.AddPropertyNotification("position", PropertyCondition.Step(mScrollingEventThreshold));
650 propertyNotification.Notified += OnPropertyChanged;
651 base.Add(ContentContainer);
653 Scrollbar = new Scrollbar();
655 //Show vertical shadow on the top (or bottom) of the scrollable when panning down (or up).
656 topOverShootingShadowView = new View
658 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_top.png",
661 PositionUsesPivotPoint = true,
662 ParentOrigin = NUI.ParentOrigin.TopCenter,
663 PivotPoint = NUI.PivotPoint.TopCenter,
665 bottomOverShootingShadowView = new View
667 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_bottom.png",
670 PositionUsesPivotPoint = true,
671 ParentOrigin = NUI.ParentOrigin.BottomCenter,
672 PivotPoint = NUI.PivotPoint.BottomCenter,
674 //Show horizontal shadow on the left (or right) of the scrollable when panning down (or up).
675 leftOverShootingShadowView = new View
677 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_left.png",
680 PositionUsesPivotPoint = true,
681 ParentOrigin = NUI.ParentOrigin.CenterLeft,
682 PivotPoint = NUI.PivotPoint.CenterLeft,
684 rightOverShootingShadowView = new View
686 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_right.png",
689 PositionUsesPivotPoint = true,
690 ParentOrigin = NUI.ParentOrigin.CenterRight,
691 PivotPoint = NUI.PivotPoint.CenterRight,
694 AccessibilityManager.Instance.SetAccessibilityAttribute(this, AccessibilityManager.AccessibilityAttribute.Trait, "ScrollableBase");
697 private bool OnInterruptTouchingChildTouched(object source, View.TouchEventArgs args)
699 if (args.Touch.GetState(0) == PointStateType.Down)
701 if (scrolling && !SnapToPage)
709 private void OnPropertyChanged(object source, PropertyNotification.NotifyEventArgs args)
715 /// Called after a child has been added to the owning view.
717 /// <param name="view">The child which has been added.</param>
718 /// <since_tizen> 8 </since_tizen>
719 public override void Add(View view)
721 ContentContainer.Add(view);
725 /// Called after a child has been removed from the owning view.
727 /// <param name="view">The child which has been removed.</param>
728 /// <since_tizen> 8 </since_tizen>
729 public override void Remove(View view)
731 if (SnapToPage && CurrentPage == Children.IndexOf(view) && CurrentPage == Children.Count - 1 && Children.Count > 1)
733 // Target View is current page and also last child.
734 // CurrentPage should be changed to previous page.
735 ScrollToIndex(CurrentPage - 1);
738 ContentContainer.Remove(view);
741 private void OnScrollingChildRelayout(object source, EventArgs args)
743 // Size is changed. Calculate maxScrollDistance.
744 bool isSizeChanged = previousContainerSize.Width != ContentContainer.Size.Width || previousContainerSize.Height != ContentContainer.Size.Height ||
745 previousSize.Width != Size.Width || previousSize.Height != Size.Height;
749 maxScrollDistance = CalculateMaximumScrollDistance();
750 if (!ReviseContainerPositionIfNeed())
756 previousContainerSize = ContentContainer.Size;
760 private bool ReviseContainerPositionIfNeed()
762 bool isHorizontal = ScrollingDirection == Direction.Horizontal;
763 float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
765 if (Math.Abs(currentPosition) > maxScrollDistance)
768 var targetPosition = BoundScrollPosition(-maxScrollDistance);
769 if (isHorizontal) ContentContainer.PositionX = targetPosition;
770 else ContentContainer.PositionY = targetPosition;
778 /// The composition of a Scrollbar can vary depending on how you use ScrollableBase.
779 /// Set the composition that will go into the ScrollableBase according to your ScrollableBase.
781 /// <since_tizen> 8 </since_tizen>
782 [EditorBrowsable(EditorBrowsableState.Never)]
783 protected virtual void SetScrollbar()
787 bool isHorizontal = ScrollingDirection == Direction.Horizontal;
788 float contentLength = isHorizontal ? ContentContainer.Size.Width : ContentContainer.Size.Height;
789 float viewportLength = isHorizontal ? Size.Width : Size.Height;
790 float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
791 Scrollbar.Initialize(contentLength, viewportLength, -currentPosition, isHorizontal);
795 /// Update scrollbar position and size.
796 [EditorBrowsable(EditorBrowsableState.Never)]
797 protected virtual void UpdateScrollbar()
801 bool isHorizontal = ScrollingDirection == Direction.Horizontal;
802 float contentLength = isHorizontal ? ContentContainer.Size.Width : ContentContainer.Size.Height;
803 float viewportLength = isHorizontal ? Size.Width : Size.Height;
804 float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
805 Scrollbar.Update(contentLength, viewportLength, -currentPosition);
810 /// Scrolls to the item at the specified index.
812 /// <param name="index">Index of item.</param>
813 /// <since_tizen> 8 </since_tizen>
814 public void ScrollToIndex(int index)
816 if (ContentContainer.ChildCount - 1 < index || index < 0)
826 float targetPosition = Math.Min(ScrollingDirection == Direction.Vertical ? Children[index].Position.Y : Children[index].Position.X, maxScrollDistance);
827 AnimateChildTo(ScrollDuration, -targetPosition);
830 private void OnScrollDragStarted()
832 ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
833 ScrollDragStarted?.Invoke(this, eventArgs);
836 private void OnScrollDragEnded()
838 ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
839 ScrollDragEnded?.Invoke(this, eventArgs);
842 private void OnScrollAnimationStarted()
844 ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
845 ScrollAnimationStarted?.Invoke(this, eventArgs);
848 private void OnScrollAnimationEnded()
851 this.InterceptTouchEvent -= OnInterruptTouchingChildTouched;
853 ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
854 ScrollAnimationEnded?.Invoke(this, eventArgs);
857 private void OnScroll()
859 ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
860 Scrolling?.Invoke(this, eventArgs);
862 bool isHorizontal = ScrollingDirection == Direction.Horizontal;
863 float contentLength = isHorizontal ? ContentContainer.Size.Width : ContentContainer.Size.Height;
864 float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
866 scrollBar?.Update(contentLength, Math.Abs(currentPosition));
867 CheckPreReachedTargetPosition();
870 private void CheckPreReachedTargetPosition()
872 // Check whether we reached pre-reached target position
874 ContentContainer.CurrentPosition.Y <= finalTargetPosition + NoticeAnimationEndBeforePosition &&
875 ContentContainer.CurrentPosition.Y >= finalTargetPosition - NoticeAnimationEndBeforePosition)
878 readyToNotice = false;
879 OnPreReachedTargetPosition(finalTargetPosition);
884 /// This helps developer who wants to know before scroll is reaching target position.
886 /// <param name="targetPosition">Index of item.</param>
887 /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
888 [EditorBrowsable(EditorBrowsableState.Never)]
889 protected virtual void OnPreReachedTargetPosition(float targetPosition)
894 private void StopScroll()
896 if (scrollAnimation != null)
898 if (scrollAnimation.State == Animation.States.Playing)
900 Debug.WriteLineIf(LayoutDebugScrollableBase, "StopScroll Animation Playing");
901 scrollAnimation.Stop(Animation.EndActions.Cancel);
902 OnScrollAnimationEnded();
904 scrollAnimation.Clear();
908 private void AnimateChildTo(int duration, float axisPosition)
910 Debug.WriteLineIf(LayoutDebugScrollableBase, "AnimationTo Animation Duration:" + duration + " Destination:" + axisPosition);
911 finalTargetPosition = axisPosition;
913 StopScroll(); // Will replace previous animation so will stop existing one.
915 if (scrollAnimation == null)
917 scrollAnimation = new Animation();
918 scrollAnimation.Finished += ScrollAnimationFinished;
921 scrollAnimation.Duration = duration;
922 scrollAnimation.DefaultAlphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.EaseOutSquare);
923 scrollAnimation.AnimateTo(ContentContainer, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", axisPosition, ScrollAlphaFunction);
925 OnScrollAnimationStarted();
926 scrollAnimation.Play();
930 /// Scroll to specific position with or without animation.
932 /// <param name="position">Destination.</param>
933 /// <param name="animate">Scroll with or without animation</param>
934 /// <since_tizen> 8 </since_tizen>
935 public void ScrollTo(float position, bool animate)
937 float currentPositionX = ContentContainer.CurrentPosition.X != 0 ? ContentContainer.CurrentPosition.X : ContentContainer.Position.X;
938 float currentPositionY = ContentContainer.CurrentPosition.Y != 0 ? ContentContainer.CurrentPosition.Y : ContentContainer.Position.Y;
939 float delta = ScrollingDirection == Direction.Horizontal ? currentPositionX : currentPositionY;
940 // The argument position is the new pan position. So the new position of ScrollableBase becomes (-position).
941 // To move ScrollableBase's position to (-position), it moves by (-position - currentPosition).
942 delta = -position - delta;
944 ScrollBy(delta, animate);
947 private float BoundScrollPosition(float targetPosition)
949 if (ScrollAvailableArea != null)
951 float minScrollPosition = ScrollAvailableArea.X;
952 float maxScrollPosition = ScrollAvailableArea.Y;
954 targetPosition = Math.Min(-minScrollPosition, targetPosition);
955 targetPosition = Math.Max(-maxScrollPosition, targetPosition);
959 targetPosition = Math.Min(0, targetPosition);
960 targetPosition = Math.Max(-maxScrollDistance, targetPosition);
963 return targetPosition;
966 private void ScrollBy(float displacement, bool animate)
968 if (GetChildCount() == 0 || maxScrollDistance < 0)
973 float childCurrentPosition = (ScrollingDirection == Direction.Horizontal) ? ContentContainer.PositionX : ContentContainer.PositionY;
975 Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy childCurrentPosition:" + childCurrentPosition +
976 " displacement:" + displacement,
977 " maxScrollDistance:" + maxScrollDistance);
979 childTargetPosition = childCurrentPosition + displacement; // child current position + gesture displacement
981 Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy currentAxisPosition:" + childCurrentPosition + "childTargetPosition:" + childTargetPosition);
985 // Calculate scroll animation duration
986 float scrollDistance = Math.Abs(displacement);
987 readyToNotice = true;
989 AnimateChildTo(ScrollDuration, BoundScrollPosition(AdjustTargetPositionOfScrollAnimation(BoundScrollPosition(childTargetPosition))));
994 finalTargetPosition = BoundScrollPosition(childTargetPosition);
996 // Set position of scrolling child without an animation
997 if (ScrollingDirection == Direction.Horizontal)
999 ContentContainer.PositionX = finalTargetPosition;
1003 ContentContainer.PositionY = finalTargetPosition;
1009 /// you can override it to clean-up your own resources.
1011 /// <param name="type">DisposeTypes</param>
1012 /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1013 [EditorBrowsable(EditorBrowsableState.Never)]
1014 protected override void Dispose(DisposeTypes type)
1021 if (type == DisposeTypes.Explicit)
1023 StopOverShootingShadowAnimation();
1026 if (mPanGestureDetector != null)
1028 mPanGestureDetector.Detected -= OnPanGestureDetected;
1029 mPanGestureDetector.Dispose();
1030 mPanGestureDetector = null;
1033 propertyNotification.Dispose();
1038 private float CalculateMaximumScrollDistance()
1040 float scrollingChildLength = 0;
1041 float scrollerLength = 0;
1042 if (ScrollingDirection == Direction.Horizontal)
1044 Debug.WriteLineIf(LayoutDebugScrollableBase, "Horizontal");
1046 scrollingChildLength = ContentContainer.Size.Width;
1047 scrollerLength = Size.Width;
1051 Debug.WriteLineIf(LayoutDebugScrollableBase, "Vertical");
1052 scrollingChildLength = ContentContainer.Size.Height;
1053 scrollerLength = Size.Height;
1056 Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy maxScrollDistance:" + (scrollingChildLength - scrollerLength) +
1057 " parent length:" + scrollerLength +
1058 " scrolling child length:" + scrollingChildLength);
1060 return Math.Max(scrollingChildLength - scrollerLength, 0);
1063 private void PageSnap(float velocity)
1067 Debug.WriteLineIf(LayoutDebugScrollableBase, "PageSnap with pan candidate totalDisplacement:" + totalDisplacementForPan +
1068 " currentPage[" + CurrentPage + "]");
1070 //Increment current page if total displacement enough to warrant a page change.
1071 if (Math.Abs(totalDisplacementForPan) > (mPageWidth * ratioOfScreenWidthToCompleteScroll))
1073 if (totalDisplacementForPan < 0)
1075 CurrentPage = Math.Min(Math.Max(Children.Count - 1, 0), ++CurrentPage);
1079 CurrentPage = Math.Max(0, --CurrentPage);
1082 else if (Math.Abs(velocity) > PageFlickThreshold)
1086 CurrentPage = Math.Min(Math.Max(Children.Count - 1, 0), ++CurrentPage);
1090 CurrentPage = Math.Max(0, --CurrentPage);
1094 // Animate to new page or reposition to current page
1095 if (ScrollingDirection == Direction.Horizontal)
1096 destination = -(Children[CurrentPage].Position.X + Children[CurrentPage].CurrentSize.Width / 2 - CurrentSize.Width / 2); // set to middle of current page
1098 destination = -(Children[CurrentPage].Position.Y + Children[CurrentPage].CurrentSize.Height / 2 - CurrentSize.Height / 2);
1100 AnimateChildTo(ScrollDuration, destination);
1104 /// Enable/Disable overshooting effect. default is disabled.
1106 [EditorBrowsable(EditorBrowsableState.Never)]
1107 public bool EnableOverShootingEffect { get; set; } = false;
1109 private void AttachOverShootingShadowView()
1111 if (!EnableOverShootingEffect)
1114 // stop animation if necessary.
1115 StopOverShootingShadowAnimation();
1117 if (ScrollingDirection == Direction.Horizontal)
1119 base.Add(leftOverShootingShadowView);
1120 base.Add(rightOverShootingShadowView);
1122 leftOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1123 leftOverShootingShadowView.Opacity = 1.0f;
1124 leftOverShootingShadowView.RaiseToTop();
1126 rightOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1127 rightOverShootingShadowView.Opacity = 1.0f;
1128 rightOverShootingShadowView.RaiseToTop();
1132 base.Add(topOverShootingShadowView);
1133 base.Add(bottomOverShootingShadowView);
1135 topOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1136 topOverShootingShadowView.Opacity = 1.0f;
1137 topOverShootingShadowView.RaiseToTop();
1139 bottomOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1140 bottomOverShootingShadowView.Opacity = 1.0f;
1141 bottomOverShootingShadowView.RaiseToTop();
1144 // at the beginning, height or width of overshooting shadow is 0, so it is invisible.
1145 isOverShootingShadowShown = false;
1148 private void DragOverShootingShadow(float totalPanDisplacement, float panDisplacement)
1150 if (!EnableOverShootingEffect)
1153 if (totalPanDisplacement > 0) // downwards
1155 // check if reaching at the top / left.
1156 if ((int)finalTargetPosition != 0)
1158 isOverShootingShadowShown = false;
1162 // save start displacement, and re-calculate displacement.
1163 if (!isOverShootingShadowShown)
1165 startShowShadowDisplacement = totalPanDisplacement;
1167 isOverShootingShadowShown = true;
1169 float newDisplacement = (int)totalPanDisplacement < (int)startShowShadowDisplacement ? 0 : totalPanDisplacement - startShowShadowDisplacement;
1171 if (ScrollingDirection == Direction.Horizontal)
1173 // scale limit of height is 60%.
1174 float heightScale = newDisplacement / overShootingShadowScaleHeightLimit;
1175 leftOverShootingShadowView.SizeHeight = heightScale > 0.6f ? SizeHeight * 0.4f : SizeHeight * (1.0f - heightScale);
1177 // scale limit of width is 300%.
1178 leftOverShootingShadowView.SizeWidth = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1181 ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1182 ScrollOutOfBoundEventArgs.Direction.Right : ScrollOutOfBoundEventArgs.Direction.Left;
1183 OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1187 // scale limit of width is 60%.
1188 float widthScale = newDisplacement / overShootingShadowScaleHeightLimit;
1189 topOverShootingShadowView.SizeWidth = widthScale > 0.6f ? SizeWidth * 0.4f : SizeWidth * (1.0f - widthScale);
1191 // scale limit of height is 300%.
1192 topOverShootingShadowView.SizeHeight = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1195 ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1196 ScrollOutOfBoundEventArgs.Direction.Down : ScrollOutOfBoundEventArgs.Direction.Up;
1197 OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1200 else if (totalPanDisplacement < 0) // upwards
1202 // check if reaching at the bottom.
1203 if (-(int)finalTargetPosition != (int)maxScrollDistance)
1205 isOverShootingShadowShown = false;
1209 // save start displacement, and re-calculate displacement.
1210 if (!isOverShootingShadowShown)
1212 startShowShadowDisplacement = totalPanDisplacement;
1214 isOverShootingShadowShown = true;
1216 float newDisplacement = (int)startShowShadowDisplacement < (int)totalPanDisplacement ? 0 : startShowShadowDisplacement - totalPanDisplacement;
1218 if (ScrollingDirection == Direction.Horizontal)
1220 // scale limit of height is 60%.
1221 float heightScale = newDisplacement / overShootingShadowScaleHeightLimit;
1222 rightOverShootingShadowView.SizeHeight = heightScale > 0.6f ? SizeHeight * 0.4f : SizeHeight * (1.0f - heightScale);
1224 // scale limit of width is 300%.
1225 rightOverShootingShadowView.SizeWidth = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1228 ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1229 ScrollOutOfBoundEventArgs.Direction.Right : ScrollOutOfBoundEventArgs.Direction.Left;
1230 OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1234 // scale limit of width is 60%.
1235 float widthScale = newDisplacement / overShootingShadowScaleHeightLimit;
1236 bottomOverShootingShadowView.SizeWidth = widthScale > 0.6f ? SizeWidth * 0.4f : SizeWidth * (1.0f - widthScale);
1238 // scale limit of height is 300%.
1239 bottomOverShootingShadowView.SizeHeight = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1242 ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1243 ScrollOutOfBoundEventArgs.Direction.Down : ScrollOutOfBoundEventArgs.Direction.Up;
1244 OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1249 // if total displacement is 0, shadow would become invisible.
1250 isOverShootingShadowShown = false;
1254 private void PlayOverShootingShadowAnimation()
1256 if (!EnableOverShootingEffect)
1259 // stop animation if necessary.
1260 StopOverShootingShadowAnimation();
1262 if (overShootingShadowAnimation == null)
1264 overShootingShadowAnimation = new Animation(overShootingShadowAnimationDuration);
1265 overShootingShadowAnimation.Finished += OnOverShootingShadowAnimationFinished;
1268 if (ScrollingDirection == Direction.Horizontal)
1270 View targetView = totalDisplacementForPan < 0 ? rightOverShootingShadowView : leftOverShootingShadowView;
1271 overShootingShadowAnimation.AnimateTo(targetView, "SizeHeight", SizeHeight);
1272 overShootingShadowAnimation.AnimateTo(targetView, "SizeWidth", 0.0f);
1273 overShootingShadowAnimation.AnimateTo(targetView, "Opacity", 0.0f);
1277 View targetView = totalDisplacementForPan < 0 ? bottomOverShootingShadowView : topOverShootingShadowView;
1278 overShootingShadowAnimation.AnimateTo(targetView, "SizeWidth", SizeWidth);
1279 overShootingShadowAnimation.AnimateTo(targetView, "SizeHeight", 0.0f);
1280 overShootingShadowAnimation.AnimateTo(targetView, "Opacity", 0.0f);
1282 overShootingShadowAnimation.Play();
1285 private void StopOverShootingShadowAnimation()
1287 if (overShootingShadowAnimation == null || overShootingShadowAnimation.State != Animation.States.Playing)
1290 overShootingShadowAnimation.Stop(Animation.EndActions.Cancel);
1291 OnOverShootingShadowAnimationFinished(null, null);
1292 overShootingShadowAnimation.Clear();
1295 private void OnOverShootingShadowAnimationFinished(object sender, EventArgs e)
1297 if (ScrollingDirection == Direction.Horizontal)
1299 base.Remove(leftOverShootingShadowView);
1300 base.Remove(rightOverShootingShadowView);
1302 leftOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1303 rightOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1307 base.Remove(topOverShootingShadowView);
1308 base.Remove(bottomOverShootingShadowView);
1310 topOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1311 bottomOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1314 // after animation finished, height/width & opacity of vertical shadow both are 0, so it is invisible.
1315 isOverShootingShadowShown = false;
1318 private void OnScrollOutOfBound(ScrollOutOfBoundEventArgs.Direction direction, float displacement)
1320 ScrollOutOfBoundEventArgs args = new ScrollOutOfBoundEventArgs(direction, displacement);
1321 ScrollOutOfBound?.Invoke(this, args);
1324 private void OnPanGestureDetected(object source, PanGestureDetector.DetectedEventArgs e)
1326 OnPanGesture(e.PanGesture);
1329 private void OnPanGesture(PanGesture panGesture)
1331 if (SnapToPage && scrollAnimation != null && scrollAnimation.State == Animation.States.Playing)
1336 if (panGesture.State == Gesture.StateType.Started)
1338 readyToNotice = false;
1339 //Interrupt touching when panning is started
1340 this.InterceptTouchEvent += OnInterruptTouchingChildTouched;
1341 AttachOverShootingShadowView();
1342 Debug.WriteLineIf(LayoutDebugScrollableBase, "Gesture Start");
1343 if (scrolling && !SnapToPage)
1347 totalDisplacementForPan = 0.0f;
1348 OnScrollDragStarted();
1350 else if (panGesture.State == Gesture.StateType.Continuing)
1352 if (ScrollingDirection == Direction.Horizontal)
1354 // if vertical shadow is shown, does not scroll.
1355 if (!isOverShootingShadowShown)
1357 ScrollBy(panGesture.Displacement.X, false);
1359 totalDisplacementForPan += panGesture.Displacement.X;
1360 DragOverShootingShadow(totalDisplacementForPan, panGesture.Displacement.X);
1364 // if vertical shadow is shown, does not scroll.
1365 if (!isOverShootingShadowShown)
1367 ScrollBy(panGesture.Displacement.Y, false);
1369 totalDisplacementForPan += panGesture.Displacement.Y;
1370 DragOverShootingShadow(totalDisplacementForPan, panGesture.Displacement.Y);
1372 Debug.WriteLineIf(LayoutDebugScrollableBase, "OnPanGestureDetected Continue totalDisplacementForPan:" + totalDisplacementForPan);
1374 else if (panGesture.State == Gesture.StateType.Finished || panGesture.State == Gesture.StateType.Cancelled)
1376 PlayOverShootingShadowAnimation();
1377 OnScrollDragEnded();
1378 StopScroll(); // Will replace previous animation so will stop existing one.
1380 if (scrollAnimation == null)
1382 scrollAnimation = new Animation();
1383 scrollAnimation.Finished += ScrollAnimationFinished;
1386 float panVelocity = (ScrollingDirection == Direction.Horizontal) ? panGesture.Velocity.X : panGesture.Velocity.Y;
1390 PageSnap(panVelocity);
1394 if (panVelocity == 0)
1396 float currentScrollPosition = (ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
1397 scrollAnimation.DefaultAlphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.Linear);
1398 scrollAnimation.Duration = 0;
1399 scrollAnimation.AnimateTo(ContentContainer, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", currentScrollPosition);
1400 scrollAnimation.Play();
1404 Decelerating(panVelocity, scrollAnimation);
1408 totalDisplacementForPan = 0;
1410 readyToNotice = true;
1411 OnScrollAnimationStarted();
1415 internal void BaseRemove(View view)
1420 internal override bool OnAccessibilityPan(PanGesture gestures)
1422 if (SnapToPage && scrollAnimation != null && scrollAnimation.State == Animation.States.Playing)
1427 OnPanGesture(gestures);
1431 private float CustomScrollAlphaFunction(float progress)
1433 if (panAnimationDelta == 0)
1439 // Parameter "progress" is normalized value. We need to multiply target duration to calculate distance.
1440 // Can get real distance using equation of deceleration (check Decelerating function)
1441 // After get real distance, normalize it
1442 float realDuration = progress * panAnimationDuration;
1443 float realDistance = velocityOfLastPan * ((float)Math.Pow(decelerationRate, realDuration) - 1) / logValueOfDeceleration;
1444 float result = Math.Min(realDistance / Math.Abs(panAnimationDelta), 1.0f);
1450 /// you can override it to custom your decelerating
1452 /// <param name="velocity">Velocity of current pan.</param>
1453 /// <param name="animation">Scroll animation.</param>
1454 [EditorBrowsable(EditorBrowsableState.Never)]
1455 protected virtual void Decelerating(float velocity, Animation animation)
1457 // Decelerating using deceleration equation ===========
1459 // V : velocity (pixel per millisecond)
1460 // V0 : initial velocity
1461 // d : deceleration rate,
1463 // X : final position after decelerating
1464 // log : natural logarithm
1466 // V(t) = V0 * d pow t;
1467 // X(t) = V0 * (d pow t - 1) / log d; <-- Integrate the velocity function
1468 // X(∞) = V0 * d / (1 - d); <-- Result using infinite T can be final position because T is tending to infinity.
1470 // Because of final T is tending to infinity, we should use threshold value to finish.
1471 // Final T = log(-threshold * log d / |V0| ) / log d;
1473 velocityOfLastPan = Math.Abs(velocity);
1475 float currentScrollPosition = -(ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
1476 panAnimationDelta = (velocityOfLastPan * decelerationRate) / (1 - decelerationRate);
1477 panAnimationDelta = velocity > 0 ? -panAnimationDelta : panAnimationDelta;
1479 float destination = -(panAnimationDelta + currentScrollPosition);
1480 float adjustDestination = AdjustTargetPositionOfScrollAnimation(destination);
1481 float maxPosition = ScrollAvailableArea != null ? ScrollAvailableArea.Y : maxScrollDistance;
1482 float minPosition = ScrollAvailableArea != null ? ScrollAvailableArea.X : 0;
1484 if (destination < -maxPosition || destination > minPosition)
1486 panAnimationDelta = velocity > 0 ? (currentScrollPosition - minPosition) : (maxPosition - currentScrollPosition);
1487 destination = velocity > 0 ? minPosition : -maxPosition;
1489 if (panAnimationDelta == 0)
1491 panAnimationDuration = 0.0f;
1495 panAnimationDuration = (float)Math.Log((panAnimationDelta * logValueOfDeceleration / velocityOfLastPan + 1), decelerationRate);
1498 Debug.WriteLineIf(LayoutDebugScrollableBase, "\n" +
1499 "OverRange======================= \n" +
1500 "[decelerationRate] " + decelerationRate + "\n" +
1501 "[logValueOfDeceleration] " + logValueOfDeceleration + "\n" +
1502 "[Velocity] " + velocityOfLastPan + "\n" +
1503 "[CurrentPosition] " + currentScrollPosition + "\n" +
1504 "[CandidateDelta] " + panAnimationDelta + "\n" +
1505 "[Destination] " + destination + "\n" +
1506 "[Duration] " + panAnimationDuration + "\n" +
1507 "================================ \n"
1512 panAnimationDuration = (float)Math.Log(-DecelerationThreshold * logValueOfDeceleration / velocityOfLastPan) / logValueOfDeceleration;
1514 if (adjustDestination != destination)
1516 destination = adjustDestination;
1517 panAnimationDelta = destination + currentScrollPosition;
1518 velocityOfLastPan = Math.Abs(panAnimationDelta * logValueOfDeceleration / ((float)Math.Pow(decelerationRate, panAnimationDuration) - 1));
1519 panAnimationDuration = (float)Math.Log(-DecelerationThreshold * logValueOfDeceleration / velocityOfLastPan) / logValueOfDeceleration;
1522 Debug.WriteLineIf(LayoutDebugScrollableBase, "\n" +
1523 "================================ \n" +
1524 "[decelerationRate] " + decelerationRate + "\n" +
1525 "[logValueOfDeceleration] " + logValueOfDeceleration + "\n" +
1526 "[Velocity] " + velocityOfLastPan + "\n" +
1527 "[CurrentPosition] " + currentScrollPosition + "\n" +
1528 "[CandidateDelta] " + panAnimationDelta + "\n" +
1529 "[Destination] " + destination + "\n" +
1530 "[Duration] " + panAnimationDuration + "\n" +
1531 "================================ \n"
1535 finalTargetPosition = destination;
1537 customScrollAlphaFunction = new UserAlphaFunctionDelegate(CustomScrollAlphaFunction);
1538 animation.DefaultAlphaFunction = new AlphaFunction(customScrollAlphaFunction);
1539 GC.KeepAlive(customScrollAlphaFunction);
1540 animation.Duration = (int)panAnimationDuration;
1541 animation.AnimateTo(ContentContainer, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", destination);
1545 private void ScrollAnimationFinished(object sender, EventArgs e)
1547 OnScrollAnimationEnded();
1551 /// Adjust scrolling position by own scrolling rules.
1552 /// Override this function when developer wants to change destination of flicking.(e.g. always snap to center of item)
1554 /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
1555 [EditorBrowsable(EditorBrowsableState.Never)]
1556 protected virtual float AdjustTargetPositionOfScrollAnimation(float position)
1562 /// Scroll position given to ScrollTo.
1563 /// This is the position in the opposite direction to the position of ContentContainer.
1565 /// <since_tizen> 8 </since_tizen>
1566 public Position ScrollPosition
1570 return new Position(-ContentContainer.Position);
1575 /// Current scroll position in the middle of ScrollTo animation.
1576 /// This is the position in the opposite direction to the current position of ContentContainer.
1578 /// <since_tizen> 8 </since_tizen>
1579 public Position ScrollCurrentPosition
1583 return new Position(-ContentContainer.CurrentPosition);
1588 /// Remove all children in ContentContainer.
1590 /// <param name="dispose">If true, removed child is disposed.</param>
1591 [EditorBrowsable(EditorBrowsableState.Never)]
1592 public void RemoveAllChildren(bool dispose = false)
1594 RecursiveRemoveChildren(ContentContainer, dispose);
1597 private void RecursiveRemoveChildren(View parent, bool dispose)
1603 int maxChild = (int)parent.GetChildCount();
1604 for (int i = maxChild - 1; i >= 0; --i)
1606 View child = parent.GetChildAt((uint)i);
1611 RecursiveRemoveChildren(child, dispose);
1612 parent.Remove(child);