*/
using System;
using System.ComponentModel;
+using System.Diagnostics;
using Tizen.NUI.BaseComponents;
using Tizen.NUI.Binding;
return ((Scrollbar)bindable).scrollbarStyle.TrackPadding;
});
- private ColorVisual trackVisual;
- private ColorVisual thumbVisual;
+ private View trackView;
+ private View thumbView;
private Animation thumbPositionAnimation;
private Animation thumbSizeAnimation;
+ private Animation opacityAnimation;
private Calculator calculator;
private Size containerSize = new Size(0, 0);
private ScrollbarStyle scrollbarStyle => ViewStyle as ScrollbarStyle;
thumbSizeAnimation?.Stop();
thumbSizeAnimation = null;
+ opacityAnimation?.Stop();
+ opacityAnimation = null;
+
PaddingType ensuredPadding = EnsurePadding(TrackPadding);
- Size trackSize = calculator.CalculateTrackSize(TrackThickness, containerSize, ensuredPadding);
- Vector2 trackPosition = calculator.CalculateTrackPosition(ensuredPadding);
- Size thumbSize = calculator.CalculateThumbSize(ThumbThickness, trackSize);
- Vector2 thumbPosition = calculator.CalculateThumbPosition(trackSize, thumbSize, ensuredPadding);
-
- trackVisual = new ColorVisual
- {
- SuppressUpdateVisual = true,
- MixColor = TrackColor,
- SizePolicy = VisualTransformPolicyType.Absolute,
- Origin = calculator.CalculatorTrackAlign(),
- AnchorPoint = calculator.CalculatorTrackAlign(),
+ var trackSize = calculator.CalculateTrackSize(TrackThickness, containerSize, ensuredPadding);
+ var trackPosition = calculator.CalculateTrackPosition(ensuredPadding);
+ var thumbSize = calculator.CalculateThumbSize(ThumbThickness, trackSize);
+ var thumbPosition = calculator.CalculateThumbPosition(trackSize, thumbSize, ensuredPadding);
+
+ trackView?.Unparent();
+ trackView = new View()
+ {
+ BackgroundColor = TrackColor,
+ ParentOrigin = calculator.CalculatorTrackAlign(),
+ PivotPoint = calculator.CalculatorTrackAlign(),
Size = trackSize,
Position = trackPosition,
+ PositionUsesPivotPoint = true,
};
+ Add(trackView);
- AddVisual("Track", trackVisual);
-
- thumbVisual = new ColorVisual
+ thumbView?.Unparent();
+ thumbView = new View()
{
- SuppressUpdateVisual = true,
- MixColor = ThumbColor,
- SizePolicy = VisualTransformPolicyType.Absolute,
- Origin = calculator.CalculatorThumbAlign(),
- AnchorPoint = calculator.CalculatorThumbAlign(),
- Opacity = calculator.CalculateThumbVisibility() ? 1.0f : 0.0f,
+ BackgroundColor = ThumbColor,
+ ParentOrigin = calculator.CalculatorThumbAlign(),
+ PivotPoint = calculator.CalculatorThumbAlign(),
Size = thumbSize,
Position = thumbPosition,
+ PositionUsesPivotPoint = true,
};
+ Add(thumbView);
- AddVisual("Thumb", thumbVisual);
+ Opacity = calculator.IsScrollable() ? 1.0f : 0.0f;
}
/// <inheritdoc/>
- /// <remarks>Please note that, for now, only alpha functions created with BuiltinFunctions are valid when animating. Otherwise, it will be treated as a linear alpha function. </remarks>
+ /// <exception cref="InvalidOperationException">Thrown when the scrollabr not yet initialized.</exception>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public override void Update(float contentLength, float viewportLength, float position, uint durationMs = 0, AlphaFunction alphaFunction = null)
+ {
+ if (calculator == null)
+ {
+ throw new InvalidOperationException("Scrollbar is not initialized. Please call Initialize() first.");
+ }
+
+ calculator.visibleLength = viewportLength;
+ Update(contentLength, position, durationMs, alphaFunction);
+ }
+
+ /// <inheritdoc/>
+ /// <exception cref="InvalidOperationException">Thrown when the scrollabr not yet initialized.</exception>
[EditorBrowsable(EditorBrowsableState.Never)]
public override void Update(float contentLength, float position, uint durationMs = 0, AlphaFunction alphaFunction = null)
{
if (calculator == null)
{
- return;
+ throw new InvalidOperationException("Scrollbar is not initialized. Please call Initialize() first.");
}
calculator.contentLength = contentLength > 0.0f ? contentLength : 0.0f;
- previousPosition = calculator.currentPosition;
calculator.currentPosition = position;
- thumbVisual.Size = calculator.CalculateThumbSize(ThumbThickness, trackVisual.Size);
- thumbVisual.Position = calculator.CalculateThumbScrollPosition(trackVisual.Size, thumbVisual.Position, EnsurePadding(TrackPadding));
- thumbVisual.Opacity = calculator.CalculateThumbVisibility() ? 1.0f : 0.0f;
+ float newOpacity = calculator.IsScrollable() ? 1.0f : 0.0f;
+ bool opacityChanged = (int)Opacity != (int)newOpacity;
+
+ var thumbSize = calculator.CalculateThumbSize(ThumbThickness, trackView.Size);
+ var thumbPosition = calculator.CalculateThumbScrollPosition(trackView.Size, thumbView.Position, EnsurePadding(TrackPadding));
if (durationMs == 0)
{
- thumbVisual.UpdateVisual(true);
+ thumbView.Position = thumbPosition;
+ thumbView.Size = thumbSize;
+ if (opacityChanged)
+ {
+ Opacity = newOpacity;
+ }
return;
}
- // TODO Support non built-in alpha function for visual trainsition in DALi.
- AlphaFunction.BuiltinFunctions builtinAlphaFunction = alphaFunction?.GetBuiltinFunction() ?? AlphaFunction.BuiltinFunctions.Default;
-
- thumbPositionAnimation?.Stop();
- thumbPositionAnimation = AnimateVisual(thumbVisual, "position", thumbVisual.Position, 0, (int)durationMs, builtinAlphaFunction);
+ EnsureThumbPositionAnimation().AnimateTo(thumbView, "Position", thumbPosition, 0, (int)durationMs, alphaFunction);
thumbPositionAnimation.Play();
- thumbSizeAnimation?.Stop();
- thumbSizeAnimation = AnimateVisual(thumbVisual, "size", thumbVisual.Size, 0, (int)durationMs, builtinAlphaFunction);
+ EnsureThumbSizeAnimation().AnimateTo(thumbView, "Size", thumbSize, 0, (int)durationMs, alphaFunction);
thumbSizeAnimation.Play();
+
+ if (opacityChanged)
+ {
+ EnsureOpacityAnimation().AnimateTo(this, "Opacity", newOpacity, 0, (int)durationMs, alphaFunction);
+ opacityAnimation.Play();
+ }
}
/// <inheritdoc/>
previousPosition = calculator.currentPosition;
calculator.currentPosition = position;
- thumbVisual.Position = calculator.CalculateThumbScrollPosition(trackVisual.Size, thumbVisual.Position, EnsurePadding(TrackPadding));
+ var thumbPosition = calculator.CalculateThumbScrollPosition(trackView.Size, thumbView.Position, EnsurePadding(TrackPadding));
if (durationMs == 0)
{
- thumbVisual.UpdateVisual(true);
-
+ thumbView.Position = thumbPosition;
return;
}
- // TODO Support non built-in alpha function for visual trainsition in DALi.
- AlphaFunction.BuiltinFunctions builtinAlphaFunction = alphaFunction?.GetBuiltinFunction() ?? AlphaFunction.BuiltinFunctions.Default;
-
- thumbPositionAnimation?.Stop();
- thumbPositionAnimation = AnimateVisual(thumbVisual, "position", thumbVisual.Position, 0, (int)durationMs, builtinAlphaFunction);
+ EnsureThumbPositionAnimation().AnimateTo(thumbView, "position", thumbPosition, 0, (int)durationMs, alphaFunction);
thumbPositionAnimation.Play();
}
}
PaddingType ensuredPadding = EnsurePadding(TrackPadding);
- trackVisual.Size = calculator.CalculateTrackSize(TrackThickness, containerSize, ensuredPadding);
- trackVisual.Position = calculator.CalculateTrackPosition(ensuredPadding);
- thumbVisual.Size = calculator.CalculateThumbSize(ThumbThickness, trackVisual.Size);
- thumbVisual.Position = calculator.CalculateThumbPosition(trackVisual.Size, thumbVisual.Size, ensuredPadding);
-
- trackVisual.UpdateVisual(true);
- thumbVisual.UpdateVisual(true);
+ trackView.Size = calculator.CalculateTrackSize(TrackThickness, containerSize, ensuredPadding);
+ trackView.Position = calculator.CalculateTrackPosition(ensuredPadding);
+ thumbView.Size = calculator.CalculateThumbSize(ThumbThickness, trackView.Size);
+ thumbView.Position = calculator.CalculateThumbPosition(trackView.Size, thumbView.Size, ensuredPadding);
}
/// <inheritdoc/>
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual void UpdateTrackThickness(float thickness)
{
- if (trackVisual == null)
+ if (trackView == null)
{
return;
}
- trackVisual.Size = calculator.CalculateTrackSize(thickness, containerSize, EnsurePadding(TrackPadding));
- trackVisual.UpdateVisual(true);
+ trackView.Size = calculator.CalculateTrackSize(thickness, containerSize, EnsurePadding(TrackPadding));
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual void UpdateThumbThickness(float thickness)
{
- if (thumbVisual == null)
+ if (thumbView == null)
{
return;
}
- thumbVisual.Size = calculator.CalculateThumbSize(thickness, trackVisual.Size);
- thumbVisual.UpdateVisual(true);
+ thumbView.Size = calculator.CalculateThumbSize(thickness, trackView.Size);
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual void UpdateTrackColor(Color color)
{
- if (trackVisual == null)
+ if (trackView == null)
{
return;
}
- trackVisual.MixColor = color;
- trackVisual.UpdateVisual(true);
+ trackView.BackgroundColor = color;
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
protected virtual void UpdateThumbColor(Color color)
{
- if (thumbVisual == null)
+ if (thumbView == null)
{
return;
}
- thumbVisual.MixColor = color;
- thumbVisual.UpdateVisual(true);
+ thumbView.BackgroundColor = color;
}
/// <summary>
/// <param name="trackPadding">The padding of the track.</param>
protected virtual void UpdateTrackPadding(Extents trackPadding)
{
- if (calculator == null || trackVisual == null || thumbVisual == null)
+ if (calculator == null || trackView == null || thumbView == null)
{
return;
}
PaddingType ensuredPadding = EnsurePadding(trackPadding);
- trackVisual.Size = calculator.CalculateTrackSize(TrackThickness, containerSize, ensuredPadding);
- trackVisual.Position = calculator.CalculateTrackPosition(ensuredPadding);
- thumbVisual.Size = calculator.CalculateThumbSize(ThumbThickness, trackVisual.Size);
- thumbVisual.Position = calculator.CalculateThumbPaddingPosition(trackVisual.Size, thumbVisual.Size, thumbVisual.Position, ensuredPadding);
-
- trackVisual.UpdateVisual(true);
- thumbVisual.UpdateVisual(true);
+ trackView.Size = calculator.CalculateTrackSize(TrackThickness, containerSize, ensuredPadding);
+ trackView.Position = calculator.CalculateTrackPosition(ensuredPadding);
+ thumbView.Size = calculator.CalculateThumbSize(ThumbThickness, trackView.Size);
+ thumbView.Position = calculator.CalculateThumbPaddingPosition(trackView.Size, thumbView.Size, thumbView.Position, ensuredPadding);
}
/// <inheritdoc/>
private PaddingType EnsurePadding(Extents padding) => padding == null ? new PaddingType(0, 0, 0 ,0) : new PaddingType(padding.Start, padding.End, padding.Top, padding.Bottom);
+ private Animation EnsureThumbPositionAnimation()
+ {
+ if (thumbPositionAnimation == null)
+ {
+ thumbPositionAnimation = new Animation();
+ }
+ else
+ {
+ thumbPositionAnimation.Stop();
+ thumbPositionAnimation.Clear();
+ }
+ return thumbPositionAnimation;
+ }
+
+ private Animation EnsureThumbSizeAnimation()
+ {
+ if (thumbSizeAnimation == null)
+ {
+ thumbSizeAnimation = new Animation();
+ }
+ else
+ {
+ thumbSizeAnimation.Stop();
+ thumbSizeAnimation.Clear();
+ }
+ return thumbSizeAnimation;
+ }
+
+ private Animation EnsureOpacityAnimation()
+ {
+ if (opacityAnimation == null)
+ {
+ opacityAnimation = new Animation();
+ }
+ else
+ {
+ opacityAnimation.Stop();
+ opacityAnimation.Clear();
+ }
+ return opacityAnimation;
+ }
+
#endregion Methods
this.currentPosition = currentPosition;
}
- public bool CalculateThumbVisibility()
+ public bool IsScrollable()
{
return contentLength > visibleLength;
}
- public abstract Visual.AlignType CalculatorTrackAlign();
- public abstract Visual.AlignType CalculatorThumbAlign();
+ public abstract Position CalculatorTrackAlign();
+ public abstract Position CalculatorThumbAlign();
public abstract Size CalculateTrackSize(float thickness, Size containerSize, PaddingType trackPadding);
- public abstract Vector2 CalculateTrackPosition(PaddingType trackPadding);
+ public abstract Position CalculateTrackPosition(PaddingType trackPadding);
public abstract Size CalculateThumbSize(float thickness, Size trackSize);
- public abstract Vector2 CalculateThumbPosition(Size trackSize, Size thumbSize, PaddingType trackPadding);
- public abstract Vector2 CalculateThumbPaddingPosition(Size trackSize, Size thumbSize, Vector2 thumbCurrentPosition, PaddingType trackPadding);
- public abstract Vector2 CalculateThumbScrollPosition(Size trackSize, Vector2 thumbCurrentPosition, PaddingType trackPadding);
+ public abstract Position CalculateThumbPosition(Size trackSize, Size thumbSize, PaddingType trackPadding);
+ public abstract Position CalculateThumbPaddingPosition(Size trackSize, Size thumbSize, Position thumbCurrentPosition, PaddingType trackPadding);
+ public abstract Position CalculateThumbScrollPosition(Size trackSize, Position thumbCurrentPosition, PaddingType trackPadding);
}
private class HorizontalCalculator : Calculator
{
}
- public override Visual.AlignType CalculatorTrackAlign()
+ public override Position CalculatorTrackAlign()
{
- return Visual.AlignType.BottomBegin;
+ return Tizen.NUI.ParentOrigin.BottomLeft;
}
- public override Visual.AlignType CalculatorThumbAlign()
+ public override Position CalculatorThumbAlign()
{
- return Visual.AlignType.BottomBegin;
+ return Tizen.NUI.ParentOrigin.BottomLeft;
}
public override Size CalculateTrackSize(float thickness, Size containerSize, PaddingType trackPadding)
return new Size(containerSize.Width - trackPadding.Item1 - trackPadding.Item2, thickness);
}
- public override Vector2 CalculateTrackPosition(PaddingType trackPadding)
+ public override Position CalculateTrackPosition(PaddingType trackPadding)
{
- return new Vector2(trackPadding.Item1, -trackPadding.Item4);
+ return new Position(trackPadding.Item1, -trackPadding.Item4);
}
public override Size CalculateThumbSize(float thickness, Size trackSize)
{
- return new Size(trackSize.Width * visibleLength / contentLength, thickness);
+ return new Size(trackSize.Width * (IsScrollable() ? (visibleLength / contentLength) : 0.0f), thickness);
}
- public override Vector2 CalculateThumbPosition(Size trackSize, Size thumbSize, PaddingType trackPadding)
+ public override Position CalculateThumbPosition(Size trackSize, Size thumbSize, PaddingType trackPadding)
{
float padding = ((trackSize.Height - thumbSize.Height) / 2.0f) + trackPadding.Item4;
- float pos = Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength);
- return new Vector2(trackPadding.Item1 + trackSize.Width * pos / contentLength, -padding);
+ return new Position(trackPadding.Item1 + (IsScrollable() ? (trackSize.Width * (Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength)) / contentLength) : 0.0f), -padding);
}
- public override Vector2 CalculateThumbPaddingPosition(Size trackSize, Size thumbSize, Vector2 thumbCurrentPosition, PaddingType trackPadding)
+ public override Position CalculateThumbPaddingPosition(Size trackSize, Size thumbSize, Position thumbCurrentPosition, PaddingType trackPadding)
{
float padding = ((trackSize.Height - thumbSize.Height) / 2.0f) + trackPadding.Item4;
- return new Vector2(thumbCurrentPosition.X, -padding);
+ return new Position(thumbCurrentPosition.X, -padding);
}
- public override Vector2 CalculateThumbScrollPosition(Size trackSize, Vector2 thumbCurrentPosition, PaddingType trackPadding)
- {
- float pos = Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength);
- return new Vector2(trackPadding.Item1 + trackSize.Width * pos / contentLength, thumbCurrentPosition.Y);
+ public override Position CalculateThumbScrollPosition(Size trackSize, Position thumbCurrentPosition, PaddingType trackPadding)
+ {
+ return new Position(trackPadding.Item1 + (IsScrollable() ? (trackSize.Width * (Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength)) / contentLength) : 0.0f), thumbCurrentPosition.Y);
}
}
{
}
- public override Visual.AlignType CalculatorTrackAlign()
+ public override Position CalculatorTrackAlign()
{
- return Visual.AlignType.TopEnd;
+ return Tizen.NUI.ParentOrigin.TopRight;
}
- public override Visual.AlignType CalculatorThumbAlign()
+ public override Position CalculatorThumbAlign()
{
- return Visual.AlignType.TopEnd;
+ return Tizen.NUI.ParentOrigin.TopRight;
}
public override Size CalculateTrackSize(float thickness, Size containerSize, PaddingType trackPadding)
return new Size(thickness, containerSize.Height - trackPadding.Item3 - trackPadding.Item4);
}
- public override Vector2 CalculateTrackPosition(PaddingType trackPadding)
+ public override Position CalculateTrackPosition(PaddingType trackPadding)
{
- return new Vector2(-trackPadding.Item2, trackPadding.Item3);
+ return new Position(-trackPadding.Item2, trackPadding.Item3);
}
public override Size CalculateThumbSize(float thickness, Size trackSize)
{
- return new Size(thickness, trackSize.Height * visibleLength / contentLength);
+ return new Size(thickness, trackSize.Height * (IsScrollable() ? (visibleLength / contentLength) : 0.0f));
}
- public override Vector2 CalculateThumbPosition(Size trackSize, Size thumbSize, PaddingType trackPadding)
+ public override Position CalculateThumbPosition(Size trackSize, Size thumbSize, PaddingType trackPadding)
{
float padding = ((trackSize.Width - thumbSize.Width) / 2.0f) + trackPadding.Item2;
- float pos = Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength);
- return new Vector2(-padding, trackPadding.Item3 + trackSize.Height * pos / contentLength);
+ return new Position(-padding, trackPadding.Item3 + (IsScrollable() ? (trackSize.Height * Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength) / contentLength) : 0.0f));
}
- public override Vector2 CalculateThumbPaddingPosition(Size trackSize, Size thumbSize, Vector2 thumbCurrentPosition, PaddingType trackPadding)
+ public override Position CalculateThumbPaddingPosition(Size trackSize, Size thumbSize, Position thumbCurrentPosition, PaddingType trackPadding)
{
float padding = ((trackSize.Width - thumbSize.Width) / 2.0f) + trackPadding.Item2;
- return new Vector2(-padding, thumbCurrentPosition.Y);
+ return new Position(-padding, thumbCurrentPosition.Y);
}
- public override Vector2 CalculateThumbScrollPosition(Size trackSize, Vector2 thumbPosition, PaddingType trackPadding)
+ public override Position CalculateThumbScrollPosition(Size trackSize, Position thumbPosition, PaddingType trackPadding)
{
- float pos = Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength);
- return new Vector2(thumbPosition.X, trackPadding.Item3 + trackSize.Height * pos / contentLength);
+ return new Position(thumbPosition.X, trackPadding.Item3 + (IsScrollable() ? (trackSize.Height * Math.Min(Math.Max(currentPosition, 0.0f), contentLength - visibleLength) / contentLength) : 0.0f));
}
}
projects / platform / core / csapi / tizenfx.git / commitdiff