Added AvaloniaUI platform (#22)

Author: taj-ny

SecureFolderFS.AvaloniaUI/.gitignore

@@ -0,0 +1,55 @@
+using System.Threading.Tasks;
+using Avalonia.Animation;
+using Avalonia.Collections;
+using SecureFolderFS.Shared.Extensions;
+
+namespace SecureFolderFS.AvaloniaUI.Animations
+{
+    internal class AnimationExtended : Animation
+    {
+        /// <summary>
+        /// Gets or sets the animated control.
+        /// </summary>
+        public required Animatable Target { get; set; }
+
+        /// <summary>
+        /// Gets or sets the setters of the first frame in the animation.
+        /// </summary>
+        /// <remarks>This property won't take effect if <see cref="AnimationExtended.Children"/> is not empty.</remarks>
+        public AvaloniaList<IAnimationSetter> From { get; set; }
+
+        /// <summary>
+        /// Gets or sets the setters of the last frame in the animation.
+        /// </summary>
+        /// <remarks>This property won't take effect if <see cref="AnimationExtended.Children"/> is not empty.</remarks>
+        public AvaloniaList<IAnimationSetter> To { get; set; }
+
+        public AnimationExtended()
+        {
+            From = new();
+            To = new();
+        }
+
+        public Task RunAnimationAsync()
+        {
+            if (Children.IsEmpty() && (!From.IsEmpty() || !To.IsEmpty()))
+            {
+                if (!From.IsEmpty())
+                {
+                    var from = new KeyFrame { Cue = new(0) };
+                    from.Setters.AddRange(From);
+                    Children.Add(from);
+                }
+
+                if (!To.IsEmpty())
+                {
+                    var to = new KeyFrame { Cue = new(1) };
+                    to.Setters.AddRange(To);
+                    Children.Add(to);
+                }
+            }
+
+            return RunAsync(Target, null);
+        }
+    }
+}

SecureFolderFS.AvaloniaUI/Animations/AnimationExtended.cs

@@ -0,0 +1,63 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Collections;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Metadata;
+using SecureFolderFS.AvaloniaUI.Animations.Transitions;
+
+namespace SecureFolderFS.AvaloniaUI.Animations
+{
+    /// <summary>
+    /// A collection of animations.
+    /// </summary>
+    internal sealed class Storyboard : Control
+    {
+        public Storyboard()
+        {
+            Animations = new();
+        }
+
+        public Task RunAnimationsAsync()
+        {
+            return Task.WhenAll(Animations.Select(x => x.RunAnimationAsync()));
+        }
+
+        // This method exists to make it possible to run the transition using Interactions
+        public void RunAnimations(object? sender, RoutedEventArgs e)
+        {
+            RunAnimationsAsync();
+        }
+
+        public static readonly StyledProperty<AvaloniaList<TransitionBase>> AnimationsProperty =
+            AvaloniaProperty.Register<Storyboard, AvaloniaList<TransitionBase>>(nameof(Animations));
+
+        [Content]
+        public AvaloniaList<TransitionBase> Animations
+        {
+            get => GetValue(AnimationsProperty);
+            set => SetValue(AnimationsProperty, value);
+        }
+
+        public static readonly AttachedProperty<AvaloniaList<Storyboard>> StoryboardsProperty =
+            AvaloniaProperty.RegisterAttached<AnimationExtended, IAvaloniaObject, AvaloniaList<Storyboard>>("Storyboards");
+
+        public static void SetStoryboards(IAvaloniaObject obj, AvaloniaList<Storyboard> value)
+        {
+            obj.SetValue(StoryboardsProperty, value);
+        }
+
+        public static AvaloniaList<Storyboard> GetStoryboards(IAvaloniaObject obj)
+        {
+            var value = (AvaloniaList<Storyboard>?)obj.GetValue(StoryboardsProperty);
+            if (value is null)
+            {
+                value = new();
+                obj.SetValue(StoryboardsProperty, value);
+            }
+
+            return value;
+        }
+    }
+}

SecureFolderFS.AvaloniaUI/Animations/Storyboard.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Styling;
+using Avalonia.VisualTree;
+
+namespace SecureFolderFS.AvaloniaUI.Animations.Transitions
+{
+    internal sealed class FadeTransition : TransitionBase
+    {
+        public required AnimationMode Mode { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to update visibility of the target before and after running the animation.
+        /// </summary>
+        public bool UpdateVisibility { get; set; }
+
+        /// <exception cref="ArgumentException">Target doesn't implement IVisual</exception>
+        protected override async Task RunAnimationAsync(IVisual target)
+        {
+            var animation = GetBaseAnimation();
+            animation.From = new(new Setter(Visual.OpacityProperty, Mode == AnimationMode.In ? 0d : 1d));
+            animation.To = new(new Setter(Visual.OpacityProperty, Mode == AnimationMode.In ? 1d : 0d));
+
+            if (UpdateVisibility && Mode == AnimationMode.In)
+                target.IsVisible = true;
+
+            await animation.RunAnimationAsync();
+
+            if (UpdateVisibility && Mode == AnimationMode.Out)
+                target.IsVisible = false;
+        }
+
+        public enum AnimationMode
+        {
+            In,
+            Out
+        }
+    }
+}

SecureFolderFS.AvaloniaUI/Animations/Transitions/FadeTransition.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Animation.Easings;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.VisualTree;
+
+namespace SecureFolderFS.AvaloniaUI.Animations.Transitions
+{
+    /// <remarks>This transition is not affected by duration.</remarks>
+    internal sealed class InfoBarTransition : TransitionBase
+    {
+        public required Mode AnimationMode { get; set; }
+
+        protected override Task RunAnimationAsync(IVisual target)
+        {
+            if (ContentBelow is not IVisual contentBelow)
+                throw new ArgumentException("ContentBelow must implement IVisual.");
+
+            TransitionBase infoBarOpacityTransition;
+            TransitionBase infoBarTranslateTransition;
+            TransitionBase contentBelowTranslateTransition;
+
+            if (AnimationMode == Mode.Show)
+            {
+                GetTransform<TranslateTransform>(contentBelow).Y = -target.Bounds.Height;
+                infoBarOpacityTransition = new FadeTransition
+                {
+                    Target = Target,
+                    Duration = TimeSpan.FromMilliseconds(600),
+                    Easing = new QuinticEaseOut(),
+                    Mode = FadeTransition.AnimationMode.In
+                };
+                infoBarTranslateTransition = new TranslateTransition
+                {
+                    Target = Target,
+                    Duration = TimeSpan.FromMilliseconds(400),
+                    Easing = new QuinticEaseOut(),
+                    From = new(0, -target.Bounds.Height)
+                };
+                contentBelowTranslateTransition = new TranslateTransition
+                {
+                    Target = ContentBelow,
+                    Duration = TimeSpan.FromMilliseconds(400),
+                    Easing = new QuinticEaseOut(),
+                    From = new(0, -target.Bounds.Height)
+                };
+            }
+            else
+            {
+                infoBarOpacityTransition = new FadeTransition
+                {
+                    Target = Target,
+                    Duration = TimeSpan.FromMilliseconds(AnimationMode == Mode.QuickHide ? 200 : 600),
+                    Easing = new QuinticEaseOut(),
+                    Mode = FadeTransition.AnimationMode.Out
+                };
+                infoBarTranslateTransition = new TranslateTransition
+                {
+                    Target = Target,
+                    Duration = TimeSpan.FromMilliseconds(AnimationMode == Mode.QuickHide ? 200 : 400),
+                    Easing = new QuinticEaseOut(),
+                    To = new(0, -target.Bounds.Height)
+                };
+                contentBelowTranslateTransition = new TranslateTransition()
+                {
+                    Target = ContentBelow,
+                    Duration = TimeSpan.FromMilliseconds(AnimationMode == Mode.QuickHide ? 200 : 400),
+                    Easing = new QuinticEaseOut(),
+                    To = new(0, -target.Bounds.Height)
+                };
+            }
+
+            return Task.WhenAll
+            (
+                infoBarOpacityTransition.RunAnimationAsync(),
+                infoBarTranslateTransition.RunAnimationAsync(),
+                contentBelowTranslateTransition.RunAnimationAsync()
+            );
+        }
+
+        public static readonly StyledProperty<Animatable> ContentBelowProperty =
+            AvaloniaProperty.Register<InfoBarTransition, Animatable>(nameof(ContentBelow));
+
+        [ResolveByName]
+        public Animatable ContentBelow
+        {
+            get => GetValue(ContentBelowProperty);
+            set => SetValue(ContentBelowProperty, value);
+        }
+
+        public enum Mode
+        {
+            Show,
+            Hide,
+            QuickHide
+        }
+    }
+}

SecureFolderFS.AvaloniaUI/Animations/Transitions/InfoBarTransition.cs

@@ -0,0 +1,13 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace SecureFolderFS.AvaloniaUI.Animations.Transitions.NavigationTransitions
+{
+    internal sealed class EntranceNavigationTransition : SlideNavigationTransition
+    {
+        [SetsRequiredMembers]
+        public EntranceNavigationTransition()
+            : base(Side.Bottom, BigOffset)
+        {
+        }
+    }
+}

SecureFolderFS.AvaloniaUI/Animations/Transitions/NavigationTransitions/EntranceNavigationTransition.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Avalonia.Animation;
+using Avalonia.Animation.Easings;
+using Avalonia.Collections;
+using Avalonia.Media;
+using Avalonia.Styling;
+using Avalonia.VisualTree;
+
+namespace SecureFolderFS.AvaloniaUI.Animations.Transitions.NavigationTransitions
+{
+    internal class SlideNavigationTransition : TransitionBase
+    {
+        public const double BigOffset = 200d;
+        public const double SmallOffset = 100d;
+
+        /// <summary>
+        /// Gets or sets the side to slide from.
+        /// </summary>
+        public required Side From { get; init; }
+
+        public required double Offset { get; init; }
+
+        [SetsRequiredMembers]
+        public SlideNavigationTransition(Side from, double offset)
+        {
+            Duration = TimeSpan.Parse("0:0:0:0.3");
+            Easing = new CubicEaseOut();
+            From = from;
+            Offset = offset;
+        }
+
+        protected override Task RunAnimationAsync(IVisual target)
+        {
+            var translateTransform = GetTransform<TranslateTransform>(target);
+            AvaloniaList<IAnimationSetter> fromSetters = null!;
+
+            switch (From)
+            {
+                case Side.Left:
+                    translateTransform.X = -Offset;
+                    fromSetters = new(new Setter(TranslateTransform.XProperty, -Offset));
+                    break;
+
+                case Side.Right:
+                    translateTransform.X = Offset;
+                    fromSetters = new(new Setter(TranslateTransform.XProperty, Offset));
+                    break;
+
+                case Side.Top:
+                    translateTransform.Y = -Offset;
+                    fromSetters = new(new Setter(TranslateTransform.YProperty, -Offset));
+                    break;
+
+                case Side.Bottom:
+                    translateTransform.Y = Offset;
+                    fromSetters = new(new Setter(TranslateTransform.YProperty, Offset));
+                    break;
+            }
+
+            var animation = GetBaseAnimation();
+            animation.From = fromSetters;
+            animation.To = From switch
+            {
+                Side.Left or Side.Right => new(new Setter(TranslateTransform.XProperty, 0d)),
+                Side.Top or Side.Bottom => new(new Setter(TranslateTransform.YProperty, 0d))
+            };
+
+            return animation.RunAnimationAsync();
+        }
+
+        public enum Side
+        {
+            Left,
+            Right,
+            Top,
+            Bottom
+        }
+    }
+}

SecureFolderFS.AvaloniaUI/Animations/Transitions/NavigationTransitions/SlideNavigationTransition.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Avalonia.VisualTree;
+
+namespace SecureFolderFS.AvaloniaUI.Animations.Transitions.NavigationTransitions
+{
+    /// <summary>
+    /// Specifies that animations are suppressed during navigation.
+    /// </summary>
+    internal sealed class SuppressNavigationTransition : TransitionBase
+    {
+        [SetsRequiredMembers]
+        public SuppressNavigationTransition()
+        {
+            Duration = TimeSpan.Zero;
+        }
+
+        protected override Task RunAnimationAsync(IVisual target)
+        {
+            return Task.CompletedTask;
+        }
+    }
+}