/// ScrollEventArgs is a class to record scroll event arguments which will sent to user.
/// </summary>
/// <since_tizen> 8 </since_tizen>
+ [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1001: Types that own disposable fields should be disposable.", Justification = "Scroll event is temporarily used for notifying scroll position update, so position will not be disposed during the event processing.")]
public class ScrollEventArgs : EventArgs
{
+ // Position class is derived class of Disposable class and they will be implicitly disposed by DisposeQueue,
+ // so that there will be no memory leak.
private Position position;
private Position scrollPosition;
public partial class ScrollableBase : Control
{
static bool LayoutDebugScrollableBase = false; // Debug flag
+ static bool focusDebugScrollableBase = false; // Debug flag
private Direction mScrollingDirection = Direction.Vertical;
private bool mScrollEnabled = true;
private int mScrollDuration = 125;
private int mPageWidth = 0;
private float mPageFlickThreshold = 0.4f;
private float mScrollingEventThreshold = 0.001f;
+ private bool fadeScrollbar = true;
private class ScrollableBaseCustomLayout : AbsoluteLayout
{
else
{
scrollBar.Show();
+ if (fadeScrollbar)
+ {
+ scrollBar.Opacity = 1.0f;
+ scrollBar.FadeOut();
+ }
+ }
+ }
+ }
+ }
+
+ /// <summary>
+ /// The boolean flag for automatic fading Scrollbar.
+ /// Scrollbar will be faded out when scroll stay in certain position longer than the threshold.
+ /// Scrollbar will be faded in scroll position changes.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool FadeScrollbar
+ {
+ get => (bool)GetValue(FadeScrollbarProperty);
+ set => SetValue(FadeScrollbarProperty, value);
+ }
+
+ private bool InternalFadeScrollbar
+ {
+ get
+ {
+ return fadeScrollbar;
+ }
+ set
+ {
+ fadeScrollbar = value;
+
+ if (scrollBar != null && !hideScrollbar)
+ {
+ if (value)
+ {
+ scrollBar.FadeOut();
+ }
+ else
+ {
+ scrollBar.Opacity = 1.0f;
+ // Removing fadeout timer and animation.
+ scrollBar.FadeIn();
}
}
}
set => noticeAnimationEndBeforePosition = value;
}
+ /// <summary>
+ /// Step scroll move distance.
+ /// Key focus originally moves focusable objects, but in ScrollableBase,
+ /// if focusable object is too far or un-exist and ScrollableBase is focusable,
+ /// it can scroll move itself by key input.
+ /// this value decide how long distance will it moves in one step.
+ /// if any value is not set, step will be moved quater size of ScrollableBase length.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public float StepScrollDistance
+ {
+ get
+ {
+ return (float)GetValue(StepScrollDistanceProperty);
+ }
+ set
+ {
+ SetValue(StepScrollDistanceProperty, value);
+ NotifyPropertyChanged();
+ }
+ }
+ private float stepScrollDistance = 0f;
+
+ /// <summary>
+ /// Wheel scroll move distance.
+ /// This value decide how long distance will it moves in wheel event.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public float WheelScrollDistance
+ {
+ get
+ {
+ return (float)GetValue(WheelScrollDistanceProperty);
+ }
+ set
+ {
+ SetValue(WheelScrollDistanceProperty, value);
+ NotifyPropertyChanged();
+ }
+ }
+ private float wheelScrollDistance = 50f;
+
+
// Let's consider more whether this needs to be set as protected.
private float finalTargetPosition;
private Animation scrollAnimation;
// Declare user alpha function delegate
- [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate float UserAlphaFunctionDelegate(float progress);
private UserAlphaFunctionDelegate customScrollAlphaFunction;
private float velocityOfLastPan = 0.0f;
private bool isOverShootingShadowShown = false;
private float startShowShadowDisplacement;
- /// <summary>
- /// Default Constructor
- /// </summary>
- /// <since_tizen> 8 </since_tizen>
- public ScrollableBase() : base()
+ private void Initialize()
{
DecelerationRate = 0.998f;
PivotPoint = NUI.PivotPoint.CenterRight,
};
+ WheelEvent += OnWheelEvent;
+
AccessibilityManager.Instance.SetAccessibilityAttribute(this, AccessibilityManager.AccessibilityAttribute.Trait, "ScrollableBase");
SetKeyboardNavigationSupport(true);
}
+ /// <summary>
+ /// Default Constructor
+ /// </summary>
+ /// <since_tizen> 8 </since_tizen>
+ public ScrollableBase() : base()
+ {
+ Initialize();
+ }
+
+ /// <summary>
+ /// Creates a new instance of a ScrollableBase with style.
+ /// </summary>
+ /// <param name="style">Creates ScrollableBase by special style defined in UX.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ScrollableBase(string style) : base(style)
+ {
+ Initialize();
+ }
+
+ /// <summary>
+ /// Creates a new instance of a ScrollableBase with style.
+ /// </summary>
+ /// <param name="style">A style applied to the newly created ScrollableBase.</param>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public ScrollableBase(ControlStyle style) : base(style)
+ {
+ Initialize();
+ }
+
private bool OnInterruptTouchingChildTouched(object source, View.TouchEventArgs args)
{
if (args.Touch.GetState(0) == PointStateType.Down)
float viewportLength = isHorizontal ? Size.Width : Size.Height;
float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
Scrollbar.Update(contentLength, viewportLength, -currentPosition);
+
+ if (!hideScrollbar && fadeScrollbar)
+ {
+ Scrollbar.FadeOut();
+ }
}
}
/// <since_tizen> 8 </since_tizen>
public void ScrollToIndex(int index)
{
- if (ContentContainer.ChildCount - 1 < index || index < 0)
+ if ((int)ContentContainer.ChildCount - 1 < index || index < 0)
{
return;
}
AnimateChildTo(ScrollDuration, -targetPosition);
}
+ internal void ScrollToChild(View child, bool anim = false)
+ {
+ if (null == FindDescendantByID(child.ID)) return;
+
+ bool isHorizontal = (ScrollingDirection == Direction.Horizontal);
+
+ float viewScreenPosition = (isHorizontal ? ScreenPosition.X : ScreenPosition.Y);
+ float childScreenPosition = (isHorizontal ? child.ScreenPosition.X : child.ScreenPosition.Y);
+ float scrollPosition = (isHorizontal ? ScrollPosition.X : ScrollPosition.Y);
+ float viewSize = (isHorizontal ? SizeWidth : SizeHeight);
+ float childSize = (isHorizontal ? child.SizeWidth : child.SizeHeight);
+
+ if (viewScreenPosition > childScreenPosition ||
+ viewScreenPosition + viewSize < childScreenPosition + childSize)
+ {// if object is outside
+ float targetPosition;
+ float dist = viewScreenPosition - childScreenPosition;
+ if (dist > 0)
+ {// if object is upper side
+ targetPosition = scrollPosition - dist;
+ }
+ else
+ {// if object is down side
+ targetPosition = scrollPosition - dist + childSize - viewSize;
+ }
+ ScrollTo(targetPosition, anim);
+ }
+ }
+
private void OnScrollDragStarted()
{
ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
ScrollDragStarted?.Invoke(this, eventArgs);
+ EmitScrollStartedEvent();
+
+ if (!hideScrollbar && fadeScrollbar)
+ {
+ scrollBar?.FadeIn();
+ }
}
private void OnScrollDragEnded()
{
ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
ScrollDragEnded?.Invoke(this, eventArgs);
+ EmitScrollFinishedEvent();
+
+ if (!hideScrollbar && fadeScrollbar)
+ {
+ scrollBar?.FadeOut();
+ }
}
private void OnScrollAnimationStarted()
{
ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
ScrollAnimationStarted?.Invoke(this, eventArgs);
+ EmitScrollStartedEvent();
+
+ if (!hideScrollbar && fadeScrollbar)
+ {
+ scrollBar?.FadeIn();
+ }
}
private void OnScrollAnimationEnded()
ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
ScrollAnimationEnded?.Invoke(this, eventArgs);
+ EmitScrollFinishedEvent();
+
+ if (!hideScrollbar && fadeScrollbar)
+ {
+ scrollBar?.FadeOut();
+ }
}
private void OnScroll()
return;
}
+ StopOverShootingShadowAnimation();
+ StopScroll();
+
if (type == DisposeTypes.Explicit)
{
- StopOverShootingShadowAnimation();
- StopScroll();
+ mPanGestureDetector?.Dispose();
+ mPanGestureDetector = null;
- if (mPanGestureDetector != null)
- {
- mPanGestureDetector.Detected -= OnPanGestureDetected;
- mPanGestureDetector.Dispose();
- mPanGestureDetector = null;
- }
+ ContentContainer?.RemovePropertyNotification(propertyNotification);
+ propertyNotification?.Dispose();
+ propertyNotification = null;
+ }
+
+ WheelEvent -= OnWheelEvent;
+
+ if (type == DisposeTypes.Explicit)
+ {
- propertyNotification.Dispose();
}
base.Dispose(type);
}
var checkFinalTargetPosition = BoundScrollPosition(checkChildTargetPosition);
handled = !((int)checkFinalTargetPosition == 0 || -(int)checkFinalTargetPosition == (int)maxScrollDistance);
// If you propagate a gesture event, return;
- if(!handled)
+ if (!handled)
{
return handled;
}
float realDuration = progress * panAnimationDuration;
float realDistance = velocityOfLastPan * ((float)Math.Pow(decelerationRate, realDuration) - 1) / logValueOfDeceleration;
float result = Math.Min(realDistance / Math.Abs(panAnimationDelta), 1.0f);
+
+ // This is hot-fix for if the velocity has very small value, result is not updated even progress done.
+ if (progress > 0.99) result = 1.0f;
+
return result;
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual void Decelerating(float velocity, Animation animation)
{
+ if (animation == null) throw new ArgumentNullException(nameof(animation));
// Decelerating using deceleration equation ===========
//
// V : velocity (pixel per millisecond)
}
}
+ internal bool IsChildNearlyVisble(View child, float offset = 0)
+ {
+ if (ScreenPosition.X - offset < child.ScreenPosition.X + child.SizeWidth &&
+ ScreenPosition.X + SizeWidth + offset > child.ScreenPosition.X &&
+ ScreenPosition.Y - offset < child.ScreenPosition.Y + child.SizeHeight &&
+ ScreenPosition.Y + SizeHeight + offset > child.ScreenPosition.Y)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
/// <inheritdoc/>
[EditorBrowsable(EditorBrowsableState.Never)]
public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled)
{
- View nextFocusedView = null;
+ bool isHorizontal = (ScrollingDirection == Direction.Horizontal);
+ float targetPosition = -(ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
+ float stepDistance = (stepScrollDistance != 0 ? stepScrollDistance : (isHorizontal ? Size.Width * 0.25f : Size.Height * 0.25f));
+
+ bool forward = ((isHorizontal && direction == View.FocusDirection.Right) ||
+ (!isHorizontal && direction == View.FocusDirection.Down) ||
+ (direction == View.FocusDirection.Clockwise));
+ bool backward = ((isHorizontal && direction == View.FocusDirection.Left) ||
+ (!isHorizontal && direction == View.FocusDirection.Up) ||
+ (direction == View.FocusDirection.CounterClockwise));
- int currentIndex = ContentContainer.Children.IndexOf(currentFocusedView);
+ View nextFocusedView = FocusManager.Instance.GetNearestFocusableActor(this, currentFocusedView, direction);
- switch (direction)
+ // Move out focus from ScrollableBase.
+ // FIXME: Forward, Backward is unimplemented other components.
+ if (direction == View.FocusDirection.Forward ||
+ direction == View.FocusDirection.Backward ||
+ (nextFocusedView == null &&
+ ((forward && maxScrollDistance - targetPosition < 0.1f) ||
+ (backward && targetPosition < 0.1f))))
{
- case View.FocusDirection.Left:
- case View.FocusDirection.Up:
- {
- if (currentIndex > 0)
- {
- nextFocusedView = ContentContainer.Children[--currentIndex];
- }
- break;
- }
- case View.FocusDirection.Right:
- case View.FocusDirection.Down:
+ var next = FocusManager.Instance.GetNearestFocusableActor(this.Parent, this, direction);
+ Debug.WriteLineIf(focusDebugScrollableBase, $"Focus move [{direction}] out from ScrollableBase! Next focus target {next}:{next?.ID}");
+ return next;
+ }
+
+ if (focusDebugScrollableBase)
+ {
+ global::System.Text.StringBuilder debugMessage = new global::System.Text.StringBuilder("=========================================================\n");
+ debugMessage.Append($"GetNextFocusableView On: {this}:{this.ID}\n");
+ debugMessage.Append($"----------------Current: {currentFocusedView}:{currentFocusedView?.ID}\n");
+ debugMessage.Append($"-------------------Next: {nextFocusedView}:{nextFocusedView?.ID}\n");
+ debugMessage.Append($"--------------Direction: {direction}\n");
+ debugMessage.Append("=========================================================");
+ Debug.WriteLineIf(focusDebugScrollableBase, debugMessage);
+ }
+
+ if (nextFocusedView != null)
+ {
+ if (null != FindDescendantByID(nextFocusedView.ID))
{
- if (currentIndex < ContentContainer.Children.Count - 1)
+ if (IsChildNearlyVisble(nextFocusedView, stepDistance) == true)
{
- nextFocusedView = ContentContainer.Children[++currentIndex];
+ ScrollToChild(nextFocusedView, true);
+ return nextFocusedView;
}
- break;
}
}
- if (nextFocusedView != null)
+ if (forward || backward)
{
- // Check next focused view is inside of visible area.
- // If it is not, move scroll position to make it visible.
- Position scrollPosition = ContentContainer.CurrentPosition;
- float targetPosition = -(ScrollingDirection == Direction.Horizontal ? scrollPosition.X : scrollPosition.Y);
+ // Fallback to current focus or scrollableBase till next focus visible in scrollable.
+ if (null != currentFocusedView && null != FindDescendantByID(currentFocusedView.ID))
+ {
+ nextFocusedView = currentFocusedView;
+ }
+ else
+ {
+ Debug.WriteLineIf(focusDebugScrollableBase, "current focus view is not decendant. return ScrollableBase!");
+ return this;
+ }
+
+ if (forward)
+ {
+ targetPosition += stepDistance;
+ targetPosition = targetPosition > maxScrollDistance ? maxScrollDistance : targetPosition;
+
+ }
+ else if (backward)
+ {
+ targetPosition -= stepDistance;
+ targetPosition = targetPosition < 0 ? 0 : targetPosition;
+ }
- float left = nextFocusedView.Position.X;
- float right = nextFocusedView.Position.X + nextFocusedView.Size.Width;
- float top = nextFocusedView.Position.Y;
- float bottom = nextFocusedView.Position.Y + nextFocusedView.Size.Height;
+ ScrollTo(targetPosition, true);
- float visibleRectangleLeft = -scrollPosition.X;
- float visibleRectangleRight = -scrollPosition.X + Size.Width;
- float visibleRectangleTop = -scrollPosition.Y;
- float visibleRectangleBottom = -scrollPosition.Y + Size.Height;
+ Debug.WriteLineIf(focusDebugScrollableBase, $"ScrollTo :({targetPosition})");
+ }
- if (ScrollingDirection == Direction.Horizontal)
+ Debug.WriteLineIf(focusDebugScrollableBase, $"return end : {nextFocusedView}:{nextFocusedView?.ID}");
+ return nextFocusedView;
+ }
+
+ /// <inheritdoc/>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ protected override bool AccessibilityScrollToChild(View child)
+ {
+ if (child == null)
+ {
+ return false;
+ }
+
+ if (ScrollingDirection == Direction.Horizontal)
+ {
+ if (child.ScreenPosition.X + child.Size.Width <= this.ScreenPosition.X)
{
- if (left < visibleRectangleLeft)
+ if (SnapToPage)
{
- targetPosition = left;
+ PageSnap(PageFlickThreshold + 1);
}
- else if (right > visibleRectangleRight)
+ else
{
- targetPosition = right - Size.Width;
+ ScrollTo((float)(child.ScreenPosition.X - ContentContainer.ScreenPosition.X), false);
}
}
- else
+ else if (child.ScreenPosition.X >= this.ScreenPosition.X + this.Size.Width)
{
- if (top < visibleRectangleTop)
+ if (SnapToPage)
{
- targetPosition = top;
+ PageSnap(-(PageFlickThreshold + 1));
}
- else if (bottom > visibleRectangleBottom)
+ else
{
- targetPosition = bottom - Size.Height;
+ ScrollTo((float)(child.ScreenPosition.X + child.Size.Width - ContentContainer.ScreenPosition.X - this.Size.Width), false);
+ }
+ }
+ }
+ else
+ {
+ if (child.ScreenPosition.Y + child.Size.Height <= this.ScreenPosition.Y)
+ {
+ if (SnapToPage)
+ {
+ PageSnap(PageFlickThreshold + 1);
+ }
+ else
+ {
+ ScrollTo((float)(child.ScreenPosition.Y - ContentContainer.ScreenPosition.Y), false);
+ }
+ }
+ else if (child.ScreenPosition.Y >= this.ScreenPosition.Y + this.Size.Height)
+ {
+ if (SnapToPage)
+ {
+ PageSnap(-(PageFlickThreshold + 1));
+ }
+ else
+ {
+ ScrollTo((float)(child.ScreenPosition.Y + child.Size.Height - ContentContainer.ScreenPosition.Y - this.Size.Height), false);
}
}
- ScrollTo(targetPosition, true);
}
- return nextFocusedView;
+ return true;
+ }
+
+ /// <inheritdoc/>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public override bool OnWheel(Wheel wheel)
+ {
+ if (wheel == null)
+ {
+ return false;
+ }
+
+ float currentScrollPosition = -(ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
+ ScrollTo(currentScrollPosition + (wheelScrollDistance * wheel.Z), false);
+
+ return true;
+ }
+
+ private bool OnWheelEvent(object o, WheelEventArgs e)
+ {
+ return OnWheel(e?.Wheel);
}
}