Merge remote-tracking branch 'origin/master' into feature/window-show-hide-with-isvisible

samples/ControlCatalog/MainView.xaml

@@ -135,6 +135,9 @@
       <TabItem Header="RadioButton">
         <pages:RadioButtonPage />
       </TabItem>
+      <TabItem Header="RefreshContainer">
+        <pages:RefreshContainerPage />
+      </TabItem>
       <TabItem Header="RelativePanel">
         <pages:RelativePanelPage />
       </TabItem>

samples/ControlCatalog/Pages/RefreshContainerPage.axaml

@@ -0,0 +1,27 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:viewModels="using:ControlCatalog.ViewModels"
+             mc:Ignorable="d"
+             d:DesignWidth="800"
+             d:DesignHeight="450"
+             x:DataType="viewModels:RefreshContainerViewModel"
+             x:Class="ControlCatalog.Pages.RefreshContainerPage">
+  <DockPanel HorizontalAlignment="Stretch"
+             Height="600"
+             VerticalAlignment="Top">
+    <Label DockPanel.Dock="Top">A control that supports pull to refresh</Label>
+    <RefreshContainer Name="Refresh"
+                      DockPanel.Dock="Bottom"
+                      HorizontalAlignment="Stretch"
+                      VerticalAlignment="Stretch"
+                      PullDirection="TopToBottom"
+                      RefreshRequested="RefreshContainerPage_RefreshRequested"
+                      Margin="5">
+      <ListBox HorizontalAlignment="Stretch"
+               VerticalAlignment="Top"
+               Items="{Binding Items}"/>
+    </RefreshContainer>
+  </DockPanel>
+</UserControl>

samples/ControlCatalog/Pages/RefreshContainerPage.axaml.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using ControlCatalog.ViewModels;
+
+namespace ControlCatalog.Pages
+{
+    public class RefreshContainerPage : UserControl
+    {
+        private RefreshContainerViewModel _viewModel;
+
+        public RefreshContainerPage()
+        {
+            this.InitializeComponent();
+
+            _viewModel = new RefreshContainerViewModel();
+
+            DataContext = _viewModel;
+        }
+
+        private async void RefreshContainerPage_RefreshRequested(object? sender, RefreshRequestedEventArgs e)
+        {
+            var deferral = e.GetDeferral();
+
+            await _viewModel.AddToTop();
+
+            deferral.Complete();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}

samples/ControlCatalog/ViewModels/RefreshContainerViewModel.cs

@@ -0,0 +1,26 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reactive;
+using System.Threading.Tasks;
+using Avalonia.Controls.Notifications;
+using ControlCatalog.Pages;
+using MiniMvvm;
+
+namespace ControlCatalog.ViewModels
+{
+    public class RefreshContainerViewModel : ViewModelBase
+    {
+        public ObservableCollection<string> Items { get; }
+
+        public RefreshContainerViewModel()
+        {
+            Items = new ObservableCollection<string>(Enumerable.Range(1, 200).Select(i => $"Item {i}"));
+        }
+
+        public async Task AddToTop()
+        {
+            await Task.Delay(3000);
+            Items.Insert(0, $"Item {200 - Items.Count}");
+        }
+    }
+}

src/Avalonia.Base/Input/GestureRecognizers/PullGestureRecognizer.cs

@@ -0,0 +1,152 @@
+using Avalonia.Input.GestureRecognizers;
+
+namespace Avalonia.Input
+{
+    public class PullGestureRecognizer : StyledElement, IGestureRecognizer
+    {
+        private IInputElement? _target;
+        private IGestureRecognizerActionsDispatcher? _actions;
+        private Point _initialPosition;
+        private int _gestureId;
+        private IPointer? _tracking;
+        private PullDirection _pullDirection;
+
+        /// <summary>
+        /// Defines the <see cref="PullDirection"/> property.
+        /// </summary>
+        public static readonly DirectProperty<PullGestureRecognizer, PullDirection> PullDirectionProperty =
+            AvaloniaProperty.RegisterDirect<PullGestureRecognizer, PullDirection>(
+                nameof(PullDirection),
+                o => o.PullDirection,
+                (o, v) => o.PullDirection = v);
+
+        public PullDirection PullDirection
+        {
+            get => _pullDirection;
+            set => SetAndRaise(PullDirectionProperty, ref _pullDirection, value);
+        }
+
+        public PullGestureRecognizer(PullDirection pullDirection)
+        {
+            PullDirection = pullDirection;
+        }
+
+        public void Initialize(IInputElement target, IGestureRecognizerActionsDispatcher actions)
+        {
+            _target = target;
+            _actions = actions;
+
+            _target?.AddHandler(InputElement.PointerPressedEvent, OnPointerPressed, Interactivity.RoutingStrategies.Tunnel | Interactivity.RoutingStrategies.Bubble);
+            _target?.AddHandler(InputElement.PointerReleasedEvent, OnPointerReleased, Interactivity.RoutingStrategies.Tunnel | Interactivity.RoutingStrategies.Bubble);
+        }
+
+        private void OnPointerPressed(object? sender, PointerPressedEventArgs e)
+        {
+            PointerPressed(e);
+        }
+
+        private void OnPointerReleased(object? sender, PointerReleasedEventArgs e)
+        {
+            PointerReleased(e);
+        }
+
+        public void PointerCaptureLost(IPointer pointer)
+        {
+            if (_tracking == pointer)
+            {
+                EndPull();
+            }
+        }
+
+        public void PointerMoved(PointerEventArgs e)
+        {
+            if (_tracking == e.Pointer && _target is Visual visual)
+            {
+                var currentPosition = e.GetPosition(visual);
+                _actions!.Capture(e.Pointer, this);
+
+                Vector delta = default;
+                switch (PullDirection)
+                {
+                    case PullDirection.TopToBottom:
+                        if (currentPosition.Y > _initialPosition.Y)
+                        {
+                            delta = new Vector(0, currentPosition.Y - _initialPosition.Y);
+                        }
+                        break;
+                    case PullDirection.BottomToTop:
+                        if (currentPosition.Y < _initialPosition.Y)
+                        {
+                            delta = new Vector(0, _initialPosition.Y - currentPosition.Y);
+                        }
+                        break;
+                    case PullDirection.LeftToRight:
+                        if (currentPosition.X > _initialPosition.X)
+                        {
+                            delta = new Vector(currentPosition.X - _initialPosition.X, 0);
+                        }
+                        break;
+                    case PullDirection.RightToLeft:
+                        if (currentPosition.X < _initialPosition.X)
+                        {
+                            delta = new Vector(_initialPosition.X - currentPosition.X, 0);
+                        }
+                        break;
+                }
+
+                _target?.RaiseEvent(new PullGestureEventArgs(_gestureId, delta, PullDirection));
+            }
+        }
+
+        public void PointerPressed(PointerPressedEventArgs e)
+        {
+            if (_target != null && _target is Visual visual && (e.Pointer.Type == PointerType.Touch || e.Pointer.Type == PointerType.Pen))
+            {
+                var position = e.GetPosition(visual);
+
+                var canPull = false;
+
+                var bounds = visual.Bounds;
+
+                switch (PullDirection)
+                {
+                    case PullDirection.TopToBottom:
+                        canPull = position.Y < bounds.Height * 0.1;
+                        break;
+                    case PullDirection.BottomToTop:
+                        canPull = position.Y > bounds.Height - (bounds.Height * 0.1);
+                        break;
+                    case PullDirection.LeftToRight:
+                        canPull = position.X < bounds.Width * 0.1;
+                        break;
+                    case PullDirection.RightToLeft:
+                        canPull = position.X > bounds.Width - (bounds.Width * 0.1);
+                        break;
+                }
+
+                if (canPull)
+                {
+                    _gestureId = PullGestureEventArgs.GetNextFreeId();
+                    _tracking = e.Pointer;
+                    _initialPosition = position;
+                }
+            }
+        }
+
+        public void PointerReleased(PointerReleasedEventArgs e)
+        {
+            if (_tracking == e.Pointer)
+            {
+                EndPull();
+            }
+        }
+
+        private void EndPull()
+        {
+            _tracking = null;
+            _initialPosition = default;
+
+            _target?.RaiseEvent(new PullGestureEndedEventArgs(_gestureId, PullDirection));
+        }
+    }
+}

src/Avalonia.Base/Input/Gestures.cs

@@ -46,6 +46,14 @@ namespace Avalonia.Input
         private static readonly WeakReference<object?> s_lastPress = new WeakReference<object?>(null);
         private static Point s_lastPressPoint;
 
+        public static readonly RoutedEvent<PullGestureEventArgs> PullGestureEvent =
+            RoutedEvent.Register<PullGestureEventArgs>(
+                "PullGesture", RoutingStrategies.Bubble, typeof(Gestures));
+
+        public static readonly RoutedEvent<PullGestureEndedEventArgs> PullGestureEndedEvent =
+            RoutedEvent.Register<PullGestureEndedEventArgs>(
+                "PullGestureEnded", RoutingStrategies.Bubble, typeof(Gestures));
+
         static Gestures()
         {
             InputElement.PointerPressedEvent.RouteFinished.Subscribe(PointerPressed);

src/Avalonia.Base/Input/InputElement.cs

@@ -442,6 +442,11 @@ namespace Avalonia.Input
             {
                 SetAndRaise(IsEffectivelyEnabledProperty, ref _isEffectivelyEnabled, value);
                 PseudoClasses.Set(":disabled", !value);
+
+                if (!IsEffectivelyEnabled && FocusManager.Instance?.Current == this)
+                {
+                    FocusManager.Instance?.Focus(null);
+                }
             }
         }
 

src/Avalonia.Base/Input/PullGestureEventArgs.cs

@@ -0,0 +1,43 @@
+using System;
+using Avalonia.Interactivity;
+
+namespace Avalonia.Input
+{
+    public class PullGestureEventArgs : RoutedEventArgs
+    {
+        public int Id { get; }
+        public Vector Delta { get; }
+        public PullDirection PullDirection { get; }
+
+        private static int _nextId = 1;
+
+        internal static int GetNextFreeId() => _nextId++;
+        
+        public PullGestureEventArgs(int id, Vector delta, PullDirection pullDirection) : base(Gestures.PullGestureEvent)
+        {
+            Id = id;
+            Delta = delta;
+            PullDirection = pullDirection;
+        }
+    }
+
+    public class PullGestureEndedEventArgs : RoutedEventArgs
+    {
+        public int Id { get; }
+        public PullDirection PullDirection { get; }
+
+        public PullGestureEndedEventArgs(int id, PullDirection pullDirection) : base(Gestures.PullGestureEndedEvent)
+        {
+            Id = id;
+            PullDirection = pullDirection;
+        }
+    }
+
+    public enum PullDirection
+    {
+        TopToBottom,
+        BottomToTop,
+        LeftToRight,
+        RightToLeft
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshCompletionDeferral.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Deferral class for notify that a work done in RefreshRequested event is done.
+    /// </summary>
+    public class RefreshCompletionDeferral
+    {
+        private Action _deferredAction;
+        private int _deferCount;
+
+        public RefreshCompletionDeferral(Action deferredAction)
+        {
+            _deferredAction = deferredAction;
+        }
+
+        public void Complete()
+        {
+            Interlocked.Decrement(ref _deferCount);
+
+            if (_deferCount == 0)
+            {
+                _deferredAction?.Invoke();
+            }
+        }
+
+        public RefreshCompletionDeferral Get()
+        {
+            Interlocked.Increment(ref _deferCount);
+
+            return this;
+        }
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshContainer.cs

@@ -0,0 +1,252 @@
+using System;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.PullToRefresh;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Represents a container control that provides a <see cref="RefreshVisualizer"/> and pull-to-refresh functionality for scrollable content.
+    /// </summary>
+    public class RefreshContainer : ContentControl
+    {
+        internal const int DefaultPullDimensionSize = 100;
+
+        private bool _hasDefaultRefreshInfoProviderAdapter;
+
+        private ScrollViewerIRefreshInfoProviderAdapter? _refreshInfoProviderAdapter;
+        private RefreshInfoProvider? _refreshInfoProvider;
+        private IDisposable? _visualizerSizeSubscription;
+        private Grid? _visualizerPresenter;
+        private RefreshVisualizer? _refreshVisualizer;
+        private bool _hasDefaultRefreshVisualizer;
+
+        /// <summary>
+        /// Defines the <see cref="RefreshRequested"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RefreshRequestedEventArgs> RefreshRequestedEvent =
+            RoutedEvent.Register<RefreshContainer, RefreshRequestedEventArgs>(nameof(RefreshRequested), RoutingStrategies.Bubble);
+
+        internal static readonly DirectProperty<RefreshContainer, ScrollViewerIRefreshInfoProviderAdapter?> RefreshInfoProviderAdapterProperty =
+            AvaloniaProperty.RegisterDirect<RefreshContainer, ScrollViewerIRefreshInfoProviderAdapter?>(nameof(RefreshInfoProviderAdapter),
+                (s) => s.RefreshInfoProviderAdapter, (s, o) => s.RefreshInfoProviderAdapter = o);
+
+        /// <summary>
+        /// Defines the <see cref="Visualizer"/> event.
+        /// </summary>
+        public static readonly DirectProperty<RefreshContainer, RefreshVisualizer?> VisualizerProperty =
+            AvaloniaProperty.RegisterDirect<RefreshContainer, RefreshVisualizer?>(nameof(Visualizer),
+                s => s.Visualizer, (s, o) => s.Visualizer = o);
+
+        /// <summary>
+        /// Defines the <see cref="PullDirection"/> event.
+        /// </summary>
+        public static readonly StyledProperty<PullDirection> PullDirectionProperty =
+            AvaloniaProperty.Register<RefreshContainer, PullDirection>(nameof(PullDirection), PullDirection.TopToBottom);
+
+        internal ScrollViewerIRefreshInfoProviderAdapter? RefreshInfoProviderAdapter
+        {
+            get => _refreshInfoProviderAdapter; set
+            {
+                _hasDefaultRefreshInfoProviderAdapter = false;
+                SetAndRaise(RefreshInfoProviderAdapterProperty, ref _refreshInfoProviderAdapter, value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="RefreshVisualizer"/> for this container.
+        /// </summary>
+        public RefreshVisualizer? Visualizer
+        {
+            get => _refreshVisualizer; set
+            {
+                if (_refreshVisualizer != null)
+                {
+                    _visualizerSizeSubscription?.Dispose();
+                    _refreshVisualizer.RefreshRequested -= Visualizer_RefreshRequested;
+                }
+
+                SetAndRaise(VisualizerProperty, ref _refreshVisualizer, value);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value that specifies the direction to pull to initiate a refresh.
+        /// </summary>
+        public PullDirection PullDirection
+        {
+            get => GetValue(PullDirectionProperty);
+            set => SetValue(PullDirectionProperty, value);
+        }
+
+        /// <summary>
+        /// Occurs when an update of the content has been initiated.
+        /// </summary>
+        public event EventHandler<RefreshRequestedEventArgs>? RefreshRequested
+        {
+            add => AddHandler(RefreshRequestedEvent, value);
+            remove => RemoveHandler(RefreshRequestedEvent, value);
+        }
+
+        public RefreshContainer()
+        {
+            _hasDefaultRefreshInfoProviderAdapter = true;
+            _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection);
+            RaisePropertyChanged(RefreshInfoProviderAdapterProperty, null, _refreshInfoProviderAdapter);
+        }
+
+        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+        {
+            base.OnApplyTemplate(e);
+
+            _visualizerPresenter = e.NameScope.Find<Grid>("PART_RefreshVisualizerPresenter");
+
+            if (_refreshVisualizer == null)
+            {
+                _hasDefaultRefreshVisualizer = true;
+                Visualizer = new RefreshVisualizer();
+            }
+            else
+            {
+                _hasDefaultRefreshVisualizer = false;
+                RaisePropertyChanged(VisualizerProperty, default, _refreshVisualizer);
+            }
+
+            OnPullDirectionChanged();
+        }
+
+        private void OnVisualizerSizeChanged(Rect obj)
+        {
+            if (_hasDefaultRefreshInfoProviderAdapter)
+            {
+                _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection);
+                RaisePropertyChanged(RefreshInfoProviderAdapterProperty, null, _refreshInfoProviderAdapter);
+            }
+        }
+
+        private void Visualizer_RefreshRequested(object? sender, RefreshRequestedEventArgs e)
+        {
+            var ev = new RefreshRequestedEventArgs(e.GetDeferral(), RefreshRequestedEvent);
+            RaiseEvent(ev);
+            ev.DecrementCount();
+        }
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            if (change.Property == RefreshInfoProviderAdapterProperty)
+            {
+                if (_refreshVisualizer != null)
+                {
+                    if (_refreshInfoProvider != null)
+                    {
+                        _refreshVisualizer.RefreshInfoProvider = _refreshInfoProvider;
+                    }
+                    else
+                    {
+                        if (RefreshInfoProviderAdapter != null && _refreshVisualizer != null)
+                        {
+                            _refreshInfoProvider = RefreshInfoProviderAdapter?.AdaptFromTree(this, _refreshVisualizer.Bounds.Size);
+
+                            if (_refreshInfoProvider != null)
+                            {
+                                _refreshVisualizer.RefreshInfoProvider = _refreshInfoProvider;
+                                RefreshInfoProviderAdapter?.SetAnimations(_refreshVisualizer);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (change.Property == VisualizerProperty)
+            {
+                if (_visualizerPresenter != null)
+                {
+                    _visualizerPresenter.Children.Clear();
+                    if (_refreshVisualizer != null)
+                    {
+                        _visualizerPresenter.Children.Add(_refreshVisualizer);
+                    }
+                }
+
+                if (_refreshVisualizer != null)
+                {
+                    _refreshVisualizer.RefreshRequested += Visualizer_RefreshRequested;
+                    _visualizerSizeSubscription = _refreshVisualizer.GetObservable(Control.BoundsProperty).Subscribe(OnVisualizerSizeChanged);
+                }
+            }
+            else if (change.Property == PullDirectionProperty)
+            {
+                OnPullDirectionChanged();
+            }
+        }
+
+        private void OnPullDirectionChanged()
+        {
+            if (_visualizerPresenter != null && _refreshVisualizer != null)
+            {
+                switch (PullDirection)
+                {
+                    case PullDirection.TopToBottom:
+                        _visualizerPresenter.VerticalAlignment = Layout.VerticalAlignment.Top;
+                        _visualizerPresenter.HorizontalAlignment = Layout.HorizontalAlignment.Stretch;
+                        if (_hasDefaultRefreshVisualizer)
+                        {
+                            _refreshVisualizer.PullDirection = PullDirection.TopToBottom;
+                            _refreshVisualizer.Height = DefaultPullDimensionSize;
+                            _refreshVisualizer.Width = double.NaN;
+                        }
+                        break;
+                    case PullDirection.BottomToTop:
+                        _visualizerPresenter.VerticalAlignment = Layout.VerticalAlignment.Bottom;
+                        _visualizerPresenter.HorizontalAlignment = Layout.HorizontalAlignment.Stretch;
+                        if (_hasDefaultRefreshVisualizer)
+                        {
+                            _refreshVisualizer.PullDirection = PullDirection.BottomToTop;
+                            _refreshVisualizer.Height = DefaultPullDimensionSize;
+                            _refreshVisualizer.Width = double.NaN;
+                        }
+                        break;
+                    case PullDirection.LeftToRight:
+                        _visualizerPresenter.VerticalAlignment = Layout.VerticalAlignment.Stretch;
+                        _visualizerPresenter.HorizontalAlignment = Layout.HorizontalAlignment.Left;
+                        if (_hasDefaultRefreshVisualizer)
+                        {
+                            _refreshVisualizer.PullDirection = PullDirection.LeftToRight;
+                            _refreshVisualizer.Width = DefaultPullDimensionSize;
+                            _refreshVisualizer.Height = double.NaN;
+                        }
+                        break;
+                    case PullDirection.RightToLeft:
+                        _visualizerPresenter.VerticalAlignment = Layout.VerticalAlignment.Stretch;
+                        _visualizerPresenter.HorizontalAlignment = Layout.HorizontalAlignment.Right;
+                        if (_hasDefaultRefreshVisualizer)
+                        {
+                            _refreshVisualizer.PullDirection = PullDirection.RightToLeft;
+                            _refreshVisualizer.Width = DefaultPullDimensionSize;
+                            _refreshVisualizer.Height = double.NaN;
+                        }
+                        break;
+                }
+
+                if (_hasDefaultRefreshInfoProviderAdapter &&
+                    _hasDefaultRefreshVisualizer &&
+                    _refreshVisualizer.Bounds.Height == DefaultPullDimensionSize &&
+                    _refreshVisualizer.Bounds.Width == DefaultPullDimensionSize)
+                {
+                    _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection);
+                    RaisePropertyChanged(RefreshInfoProviderAdapterProperty, null, _refreshInfoProviderAdapter);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initiates an update of the content.
+        /// </summary>
+        public void RequestRefresh()
+        {
+            _refreshVisualizer?.RequestRefresh();
+        }
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshInfoProvider.cs

@@ -0,0 +1,141 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Rendering.Composition;
+
+namespace Avalonia.Controls.PullToRefresh
+{
+    internal class RefreshInfoProvider : Interactive
+    {
+        internal const double DefaultExecutionRatio = 0.8;
+
+        private readonly PullDirection _refreshPullDirection;
+        private readonly Size _refreshVisualizerSize;
+
+        private readonly CompositionVisual? _visual;
+        private bool _isInteractingForRefresh;
+        private double _interactionRatio;
+        private bool _entered;
+
+        public DirectProperty<RefreshInfoProvider, bool> IsInteractingForRefreshProperty =
+            AvaloniaProperty.RegisterDirect<RefreshInfoProvider, bool>(nameof(IsInteractingForRefresh),
+                s => s.IsInteractingForRefresh, (s, o) => s.IsInteractingForRefresh = o);
+
+
+        public DirectProperty<RefreshInfoProvider, double> ExecutionRatioProperty =
+            AvaloniaProperty.RegisterDirect<RefreshInfoProvider, double>(nameof(ExecutionRatio),
+                s => s.ExecutionRatio);
+
+        public DirectProperty<RefreshInfoProvider, double> InteractionRatioProperty =
+            AvaloniaProperty.RegisterDirect<RefreshInfoProvider, double>(nameof(InteractionRatio),
+                s => s.InteractionRatio, (s, o) => s.InteractionRatio = o);
+
+        /// <summary>
+        /// Defines the <see cref="RefreshStarted"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> RefreshStartedEvent =
+            RoutedEvent.Register<RefreshInfoProvider, RoutedEventArgs>(nameof(RefreshStarted), RoutingStrategies.Bubble);
+
+        /// <summary>
+        /// Defines the <see cref="RefreshCompleted"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> RefreshCompletedEvent =
+            RoutedEvent.Register<RefreshInfoProvider, RoutedEventArgs>(nameof(RefreshCompleted), RoutingStrategies.Bubble);
+
+        public bool PeekingMode { get; internal set; }
+
+        public bool IsInteractingForRefresh
+        {
+            get => _isInteractingForRefresh;
+            internal set
+            {
+                var isInteractingForRefresh = value && !PeekingMode;
+
+                if (isInteractingForRefresh != _isInteractingForRefresh)
+                {
+                    SetAndRaise(IsInteractingForRefreshProperty, ref _isInteractingForRefresh, isInteractingForRefresh);
+                }
+            }
+        }
+
+        public double InteractionRatio
+        {
+            get => _interactionRatio;
+            set
+            {
+                SetAndRaise(InteractionRatioProperty, ref _interactionRatio, value);
+            }
+        }
+
+        public double ExecutionRatio
+        {
+            get => DefaultExecutionRatio;
+        }
+
+        internal CompositionVisual? Visual => _visual;
+
+        public event EventHandler<RoutedEventArgs> RefreshStarted
+        {
+            add => AddHandler(RefreshStartedEvent, value);
+            remove => RemoveHandler(RefreshStartedEvent, value);
+        }
+
+        public event EventHandler<RoutedEventArgs> RefreshCompleted
+        {
+            add => AddHandler(RefreshCompletedEvent, value);
+            remove => RemoveHandler(RefreshCompletedEvent, value);
+        }
+
+        internal void InteractingStateEntered(object? sender, PullGestureEventArgs e)
+        {
+            if (!_entered)
+            {
+                IsInteractingForRefresh = true;
+                _entered = true;
+            }
+
+            ValuesChanged(e.Delta);
+        }
+
+        internal void InteractingStateExited(object? sender, PullGestureEndedEventArgs e)
+        {
+            IsInteractingForRefresh = false;
+            _entered = false;
+
+            ValuesChanged(default);
+        }
+
+
+        public RefreshInfoProvider(PullDirection refreshPullDirection, Size? refreshVIsualizerSize, CompositionVisual? visual)
+        {
+            _refreshPullDirection = refreshPullDirection;
+            _refreshVisualizerSize = refreshVIsualizerSize ?? default;
+            _visual = visual;
+        }
+
+        public void OnRefreshStarted()
+        {
+            RaiseEvent(new RoutedEventArgs(RefreshStartedEvent));
+        }
+
+        public void OnRefreshCompleted()
+        {
+            RaiseEvent(new RoutedEventArgs(RefreshCompletedEvent));
+        }
+
+        internal void ValuesChanged(Vector value)
+        {
+            switch (_refreshPullDirection)
+            {
+                case PullDirection.TopToBottom:
+                case PullDirection.BottomToTop:
+                    InteractionRatio = _refreshVisualizerSize.Height == 0 ? 1 : Math.Min(1, value.Y / _refreshVisualizerSize.Height);
+                    break;
+                case PullDirection.LeftToRight:
+                case PullDirection.RightToLeft:
+                    InteractionRatio = _refreshVisualizerSize.Height == 0 ? 1 : Math.Min(1, value.X / _refreshVisualizerSize.Width);
+                    break;
+            }
+        }
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshRequestedEventArgs.cs

@@ -0,0 +1,42 @@
+using System;
+using Avalonia.Interactivity;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Provides event data for RefreshRequested events.
+    /// </summary>
+    public class RefreshRequestedEventArgs : RoutedEventArgs
+    {
+        private RefreshCompletionDeferral _refreshCompletionDeferral;
+
+        /// <summary>
+        /// Gets a deferral object for managing the work done in the RefreshRequested event handler.
+        /// </summary>
+        /// <returns>A <see cref="RefreshCompletionDeferral"/> object</returns>
+        public RefreshCompletionDeferral GetDeferral()
+        {
+            return _refreshCompletionDeferral.Get();
+        }
+
+        public RefreshRequestedEventArgs(Action deferredAction, RoutedEvent? routedEvent) : base(routedEvent)
+        {
+            _refreshCompletionDeferral = new RefreshCompletionDeferral(deferredAction);
+        }
+
+        public RefreshRequestedEventArgs(RefreshCompletionDeferral completionDeferral, RoutedEvent? routedEvent) : base(routedEvent)
+        {
+            _refreshCompletionDeferral = completionDeferral;
+        }
+
+        internal void IncrementCount()
+        {
+            _refreshCompletionDeferral?.Get();
+        }
+
+        internal void DecrementCount()
+        {
+            _refreshCompletionDeferral?.Complete();
+        }
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs

@@ -0,0 +1,553 @@
+using System;
+using System.Numerics;
+using System.Reactive.Linq;
+using Avalonia.Animation.Easings;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.PullToRefresh;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.Rendering.Composition;
+using Avalonia.Rendering.Composition.Animations;
+
+namespace Avalonia.Controls
+{
+    public class RefreshVisualizer : ContentControl
+    {
+        private const int DefaultIndicatorSize = 24;
+        private const float MinimumIndicatorOpacity = 0.4f;
+        private const float ParallaxPositionRatio = 0.5f;
+        private double _executingRatio = 0.8;
+
+        private RefreshVisualizerState _refreshVisualizerState;
+        private RefreshInfoProvider? _refreshInfoProvider;
+        private IDisposable? _isInteractingSubscription;
+        private IDisposable? _interactionRatioSubscription;
+        private bool _isInteractingForRefresh;
+        private Grid? _root;
+        private Control? _content;
+        private RefreshVisualizerOrientation _orientation;
+        private float _startingRotationAngle;
+        private double _interactionRatio;
+        private bool _played;
+        private ScalarKeyFrameAnimation? _rotateAnimation;
+
+        private bool IsPullDirectionVertical => PullDirection == PullDirection.TopToBottom || PullDirection == PullDirection.BottomToTop;
+        private bool IsPullDirectionFar => PullDirection == PullDirection.BottomToTop || PullDirection == PullDirection.RightToLeft;
+
+        /// <summary>
+        /// Defines the <see cref="PullDirection"/> property.
+        /// </summary>
+        public static readonly StyledProperty<PullDirection> PullDirectionProperty =
+            AvaloniaProperty.Register<RefreshVisualizer, PullDirection>(nameof(PullDirection), PullDirection.TopToBottom);
+
+        /// <summary>
+        /// Defines the <see cref="RefreshRequested"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RefreshRequestedEventArgs> RefreshRequestedEvent =
+            RoutedEvent.Register<RefreshVisualizer, RefreshRequestedEventArgs>(nameof(RefreshRequested), RoutingStrategies.Bubble);
+
+        /// <summary>
+        /// Defines the <see cref="RefreshVisualizerState"/> property.
+        /// </summary>
+        public static readonly DirectProperty<RefreshVisualizer, RefreshVisualizerState> RefreshVisualizerStateProperty =
+            AvaloniaProperty.RegisterDirect<RefreshVisualizer, RefreshVisualizerState>(nameof(RefreshVisualizerState),
+                s => s.RefreshVisualizerState);
+
+        /// <summary>
+        /// Defines the <see cref="Orientation"/> property.
+        /// </summary>
+        public static readonly DirectProperty<RefreshVisualizer, RefreshVisualizerOrientation> OrientationProperty =
+            AvaloniaProperty.RegisterDirect<RefreshVisualizer, RefreshVisualizerOrientation>(nameof(Orientation),
+                s => s.Orientation, (s, o) => s.Orientation = o);
+
+        /// <summary>
+        /// Defines the <see cref="RefreshInfoProvider"/> property.
+        /// </summary>
+        internal DirectProperty<RefreshVisualizer, RefreshInfoProvider?> RefreshInfoProviderProperty =
+            AvaloniaProperty.RegisterDirect<RefreshVisualizer, RefreshInfoProvider?>(nameof(RefreshInfoProvider),
+                s => s.RefreshInfoProvider, (s, o) => s.RefreshInfoProvider = o);
+
+        /// <summary>
+        /// Gets or sets a value that indicates the refresh state of the visualizer.
+        /// </summary>
+        protected RefreshVisualizerState RefreshVisualizerState
+        {
+            get
+            {
+                return _refreshVisualizerState;
+            }
+            private set
+            {
+                SetAndRaise(RefreshVisualizerStateProperty, ref _refreshVisualizerState, value);
+                UpdateContent();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value that indicates the orientation of the visualizer.
+        /// </summary>
+        public RefreshVisualizerOrientation Orientation
+        {
+            get
+            {
+                return _orientation;
+            }
+            set
+            {
+                SetAndRaise(OrientationProperty, ref _orientation, value);
+            }
+        }
+
+        internal PullDirection PullDirection
+        {
+            get => GetValue(PullDirectionProperty);
+            set => SetValue(PullDirectionProperty, value);
+        }
+
+        internal RefreshInfoProvider? RefreshInfoProvider
+        {
+            get => _refreshInfoProvider; 
+            set
+            {
+                if (_refreshInfoProvider != null)
+                {
+                    _refreshInfoProvider.RenderTransform = null;
+                }
+                SetAndRaise(RefreshInfoProviderProperty, ref _refreshInfoProvider, value);
+            }
+        }
+
+        /// <summary>
+        /// Occurs when an update of the content has been initiated.
+        /// </summary>
+        public event EventHandler<RefreshRequestedEventArgs>? RefreshRequested
+        {
+            add => AddHandler(RefreshRequestedEvent, value);
+            remove => RemoveHandler(RefreshRequestedEvent, value);
+        }
+
+        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+        {
+            base.OnApplyTemplate(e);
+
+            this.ClipToBounds = false;
+
+            _root = e.NameScope.Find<Grid>("PART_Root");
+
+            if (_root != null)
+            {
+                _content = Content as Control;
+
+                if (_content == null)
+                {
+                    _content = new PathIcon()
+                    {
+                        Height = DefaultIndicatorSize,
+                        Width = DefaultIndicatorSize,
+                        Name = "PART_Icon"
+                    };
+
+                    _content.Loaded += (s, e) =>
+                    {
+                        var composition = ElementComposition.GetElementVisual(_content);
+                        var compositor = composition!.Compositor;
+                        composition.Opacity = 0;
+
+                        var smoothRotationAnimation
+                            = compositor.CreateScalarKeyFrameAnimation();
+                        smoothRotationAnimation.Target = "RotationAngle";
+                        smoothRotationAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue", new LinearEasing());
+                        smoothRotationAnimation.Duration = TimeSpan.FromMilliseconds(100);
+
+                        var opacityAnimation
+                            = compositor.CreateScalarKeyFrameAnimation();
+                        opacityAnimation.Target = "Opacity";
+                        opacityAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue", new LinearEasing());
+                        opacityAnimation.Duration = TimeSpan.FromMilliseconds(100);
+
+                        var offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
+                        offsetAnimation.Target = "Offset";
+                        offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue", new LinearEasing());
+                        offsetAnimation.Duration = TimeSpan.FromMilliseconds(150);
+
+                        var scaleAnimation
+                            = compositor.CreateVector3KeyFrameAnimation();
+                        scaleAnimation.Target = "Scale";
+                        scaleAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue", new LinearEasing());
+                        scaleAnimation.Duration = TimeSpan.FromMilliseconds(100);
+
+                        var animation = compositor.CreateImplicitAnimationCollection();
+                        animation["RotationAngle"] = smoothRotationAnimation;
+                        animation["Offset"] = offsetAnimation;
+                        animation["Scale"] = scaleAnimation;
+                        animation["Opacity"] = opacityAnimation;
+
+                        composition.ImplicitAnimations = animation;
+
+                        UpdateContent();
+                    };
+
+                    Content = _content;
+                }
+                else
+                {
+                    RaisePropertyChanged(ContentProperty, null, Content, Data.BindingPriority.Style, false);
+                }
+            }
+
+            OnOrientationChanged();
+
+            UpdateContent();
+        }
+
+        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnAttachedToVisualTree(e);
+
+            UpdateContent();
+        }
+
+        private void UpdateContent()
+        {
+            if (_content != null && _root != null)
+            {
+                var root = _root;
+                var visual = _refreshInfoProvider?.Visual;
+                var contentVisual = ElementComposition.GetElementVisual(_content);
+                var visualizerVisual = ElementComposition.GetElementVisual(this);
+                if (visual != null && contentVisual != null && visualizerVisual != null)
+                {
+                    contentVisual.CenterPoint = new Vector3((float)(_content.Bounds.Width / 2), (float)(_content.Bounds.Height / 2), 0);
+                    switch (RefreshVisualizerState)
+                    {
+                        case RefreshVisualizerState.Idle:
+                            _played = false;
+                            if(_rotateAnimation != null)
+                            {
+                                _rotateAnimation.IterationBehavior = AnimationIterationBehavior.Count;
+                                _rotateAnimation = null;
+                            }
+                            contentVisual.Opacity = MinimumIndicatorOpacity;
+                            contentVisual.RotationAngle = _startingRotationAngle;
+                            visualizerVisual.Offset = IsPullDirectionVertical ?
+                                new Vector3(visualizerVisual.Offset.X, 0, 0) :
+                                new Vector3(0, visualizerVisual.Offset.Y, 0);
+                            visual.Offset = default;
+                            _content.InvalidateMeasure();
+                            break;
+                        case RefreshVisualizerState.Interacting:
+                            _played = false;
+                            contentVisual.Opacity = MinimumIndicatorOpacity;
+                            contentVisual.RotationAngle = (float)(_startingRotationAngle + _interactionRatio * 2 * Math.PI);
+                            Vector3 offset = default;
+                            if (IsPullDirectionVertical)
+                            {
+                                offset = new Vector3(0, (float)(_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height), 0);
+                            }
+                            else
+                            {
+                                offset = new Vector3((float)(_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width), 0, 0);
+                            }
+                            visual.Offset = offset;
+                            visualizerVisual.Offset = IsPullDirectionVertical ? 
+                                new Vector3(visualizerVisual.Offset.X, offset.Y, 0) :
+                                new Vector3(offset.X, visualizerVisual.Offset.Y, 0);
+                            break;
+                        case RefreshVisualizerState.Pending:
+                            contentVisual.Opacity = 1;
+                            contentVisual.RotationAngle = _startingRotationAngle + (float)(2 * Math.PI);
+                            if (IsPullDirectionVertical)
+                            {
+                                offset = new Vector3(0, (float)(_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height), 0);
+                            }
+                            else
+                            {
+                                offset = new Vector3((float)(_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width), 0, 0);
+                            }
+                            visual.Offset = offset;
+                            visualizerVisual.Offset = IsPullDirectionVertical ? 
+                                new Vector3(visualizerVisual.Offset.X, offset.Y, 0) : 
+                                new Vector3(offset.X, visualizerVisual.Offset.Y, 0);
+
+                            if (!_played)
+                            {
+                                _played = true;
+                                var scaleAnimation = contentVisual.Compositor!.CreateVector3KeyFrameAnimation();
+                                scaleAnimation.Target = "Scale";
+                                scaleAnimation.InsertKeyFrame(0.5f, new Vector3(1.5f, 1.5f, 1));
+                                scaleAnimation.InsertKeyFrame(1f, new Vector3(1f, 1f, 1));
+                                scaleAnimation.Duration = TimeSpan.FromSeconds(0.3);
+
+                                contentVisual.StartAnimation("Scale", scaleAnimation);
+                            }
+                            break;
+                        case RefreshVisualizerState.Refreshing:
+                            _rotateAnimation = contentVisual.Compositor!.CreateScalarKeyFrameAnimation();
+                            _rotateAnimation.Target = "RotationAngle";
+                            _rotateAnimation.InsertKeyFrame(0, _startingRotationAngle, new LinearEasing());
+                            _rotateAnimation.InsertKeyFrame(1, _startingRotationAngle + (float)(2 * Math.PI), new LinearEasing());
+                            _rotateAnimation.IterationBehavior = AnimationIterationBehavior.Forever;
+                            _rotateAnimation.StopBehavior = AnimationStopBehavior.LeaveCurrentValue;
+                            _rotateAnimation.Duration = TimeSpan.FromSeconds(0.5);
+
+                            contentVisual.StartAnimation("RotationAngle", _rotateAnimation);
+                            contentVisual.Opacity = 1;
+                            float translationRatio = (float)(_refreshInfoProvider != null ?  (1.0f - _refreshInfoProvider.ExecutionRatio) * ParallaxPositionRatio : 1.0f) 
+                                * (IsPullDirectionFar ? -1f : 1f);
+                            if (IsPullDirectionVertical)
+                            {
+                                offset = new Vector3(0, (float)(_executingRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height), 0);
+                            }
+                            else
+                            {
+                                offset = new Vector3((float)(_executingRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width), 0, 0);
+                            }
+                            visual.Offset = offset;
+                            contentVisual.Offset += IsPullDirectionVertical ? new Vector3(0, (float)(translationRatio * root.Bounds.Height), 0) :
+                                new Vector3((float)(translationRatio * root.Bounds.Width), 0, 0);
+                            visualizerVisual.Offset = IsPullDirectionVertical ?
+                                new Vector3(visualizerVisual.Offset.X, offset.Y, 0) :
+                                new Vector3(offset.X, visualizerVisual.Offset.Y, 0);
+                            break;
+                        case RefreshVisualizerState.Peeking:
+                            contentVisual.Opacity = 1;
+                            contentVisual.RotationAngle = _startingRotationAngle;
+                            break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initiates an update of the content.
+        /// </summary>
+        public void RequestRefresh()
+        {
+            RefreshVisualizerState = RefreshVisualizerState.Refreshing;
+            RefreshInfoProvider?.OnRefreshStarted();
+
+            RaiseRefreshRequested();
+        }
+
+        private void RefreshCompleted()
+        {
+            RefreshVisualizerState = RefreshVisualizerState.Idle;
+
+            RefreshInfoProvider?.OnRefreshCompleted();
+        }
+
+        private void RaiseRefreshRequested()
+        {
+            var refreshArgs = new RefreshRequestedEventArgs(RefreshCompleted, RefreshRequestedEvent);
+
+            refreshArgs.IncrementCount();
+
+            RaiseEvent(refreshArgs);
+
+            refreshArgs.DecrementCount();
+        }
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            if (change.Property == RefreshInfoProviderProperty)
+            {
+                OnRefreshInfoProviderChanged();
+            }
+            else if (change.Property == ContentProperty)
+            {
+                if (_root != null && _content != null)
+                {
+                    _root.Children.Insert(0, _content);
+                    _content.VerticalAlignment = Layout.VerticalAlignment.Center;
+                    _content.HorizontalAlignment = Layout.HorizontalAlignment.Center;
+                }
+
+                UpdateContent();
+            }
+            else if (change.Property == OrientationProperty)
+            {
+                OnOrientationChanged();
+
+                UpdateContent();
+            }
+            else if (change.Property == BoundsProperty)
+            {
+                switch (PullDirection)
+                {
+                    case PullDirection.TopToBottom:
+                        RenderTransform = new TranslateTransform(0, -Bounds.Height);
+                        break;
+                    case PullDirection.BottomToTop:
+                        RenderTransform = new TranslateTransform(0, Bounds.Height);
+                        break;
+                    case PullDirection.LeftToRight:
+                        RenderTransform = new TranslateTransform(-Bounds.Width, 0);
+                        break;
+                    case PullDirection.RightToLeft:
+                        RenderTransform = new TranslateTransform(Bounds.Width, 0);
+                        break;
+                }
+
+                UpdateContent();
+            }
+            else if(change.Property == PullDirectionProperty)
+            {
+                OnOrientationChanged();
+
+                UpdateContent();
+            }
+        }
+
+        private void OnOrientationChanged()
+        {
+            switch (_orientation)
+            {
+                case RefreshVisualizerOrientation.Auto:
+                    switch (PullDirection)
+                    {
+                        case PullDirection.TopToBottom:
+                        case PullDirection.BottomToTop:
+                            _startingRotationAngle = 0.0f;
+                            break;
+                        case PullDirection.LeftToRight:
+                            _startingRotationAngle = (float)(-Math.PI / 2);
+                            break;
+                        case PullDirection.RightToLeft:
+                            _startingRotationAngle = (float)(Math.PI / 2);
+                            break;
+                    }
+                    break;
+                case RefreshVisualizerOrientation.Normal:
+                    _startingRotationAngle = 0.0f;
+                    break;
+                case RefreshVisualizerOrientation.Rotate90DegreesCounterclockwise:
+                    _startingRotationAngle = (float)(Math.PI / 2);
+                    break;
+                case RefreshVisualizerOrientation.Rotate270DegreesCounterclockwise:
+                    _startingRotationAngle = (float)(-Math.PI / 2);
+                    break;
+            }
+        }
+
+        private void OnRefreshInfoProviderChanged()
+        {
+            _isInteractingSubscription?.Dispose();
+            _isInteractingSubscription = null;
+            _interactionRatioSubscription?.Dispose();
+            _interactionRatioSubscription = null;
+
+            if (RefreshInfoProvider != null)
+            {
+                _isInteractingSubscription = RefreshInfoProvider.GetObservable(RefreshInfoProvider.IsInteractingForRefreshProperty)
+                    .Subscribe(InteractingForRefreshObserver);
+
+                _interactionRatioSubscription = RefreshInfoProvider.GetObservable(RefreshInfoProvider.InteractionRatioProperty)
+                    .Subscribe(InteractionRatioObserver);
+
+                var visual = RefreshInfoProvider.Visual;
+
+                _executingRatio = RefreshInfoProvider.ExecutionRatio;
+            }
+            else
+            {
+                _executingRatio = 1;
+            }
+        }
+
+        private void InteractionRatioObserver(double obj)
+        {
+            var wasAtZero = _interactionRatio == 0.0;
+            _interactionRatio = obj;
+
+            if (_isInteractingForRefresh)
+            {
+                if (RefreshVisualizerState == RefreshVisualizerState.Idle)
+                {
+                    if (wasAtZero)
+                    {
+                        if (_interactionRatio > _executingRatio)
+                        {
+                            RefreshVisualizerState = RefreshVisualizerState.Pending;
+                        }
+                        else if (_interactionRatio > 0)
+                        {
+                            RefreshVisualizerState = RefreshVisualizerState.Interacting;
+                        }
+                    }
+                    else if (_interactionRatio > 0)
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Peeking;
+                    }
+                }
+                else if (RefreshVisualizerState == RefreshVisualizerState.Interacting)
+                {
+                    if (_interactionRatio <= 0)
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Idle;
+                    }
+                    else if (_interactionRatio > _executingRatio)
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Pending;
+                    }
+                    else
+                    {
+                        UpdateContent();
+                    }
+                }
+                else if (RefreshVisualizerState == RefreshVisualizerState.Pending)
+                {
+                    if (_interactionRatio <= _executingRatio)
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Interacting;
+                    }
+                    else if (_interactionRatio <= 0)
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Idle;
+                    }
+                    else
+                    {
+                        UpdateContent();
+                    }
+                }
+            }
+            else
+            {
+                if (RefreshVisualizerState != RefreshVisualizerState.Refreshing)
+                {
+                    if (_interactionRatio > 0)
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Peeking;
+                    }
+                    else
+                    {
+                        RefreshVisualizerState = RefreshVisualizerState.Idle;
+                    }
+                }
+            }
+        }
+
+        private void InteractingForRefreshObserver(bool obj)
+        {
+            _isInteractingForRefresh = obj;
+
+            if (!_isInteractingForRefresh)
+            {
+                switch (_refreshVisualizerState)
+                {
+                    case RefreshVisualizerState.Pending:
+                        RequestRefresh();
+                        break;
+                    case RefreshVisualizerState.Refreshing:
+                        // We don't want to interrupt a currently executing refresh.
+                        break;
+                    default:
+                        RefreshVisualizerState = RefreshVisualizerState.Idle;
+                        break;
+                }
+            }
+        }
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshVisualizerOrientation.cs

@@ -0,0 +1,13 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Defines constants that specify the orientation of a RefreshVisualizer.
+    /// </summary>
+    public enum RefreshVisualizerOrientation
+    {
+        Auto,
+        Normal,
+        Rotate90DegreesCounterclockwise,
+        Rotate270DegreesCounterclockwise
+    }
+}

src/Avalonia.Controls/PullToRefresh/RefreshVisualizerState.cs

@@ -0,0 +1,14 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Defines constants that specify the state of a RefreshVisualizer
+    /// </summary>
+    public enum RefreshVisualizerState
+    {
+        Idle,
+        Peeking,
+        Interacting,
+        Pending,
+        Refreshing
+    }
+}

src/Avalonia.Controls/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapter.cs

@@ -0,0 +1,274 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+using Avalonia.Rendering.Composition;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Controls.PullToRefresh
+{
+    internal class ScrollViewerIRefreshInfoProviderAdapter
+    {
+        private const int MaxSearchDepth = 10;
+        private const int InitialOffsetThreshold = 1;
+
+        private PullDirection _refreshPullDirection;
+        private ScrollViewer? _scrollViewer;
+        private RefreshInfoProvider? _refreshInfoProvider;
+        private PullGestureRecognizer? _pullGestureRecognizer;
+        private InputElement? _interactionSource;
+        private bool _isVisualizerInteractionSourceAttached;
+
+        public ScrollViewerIRefreshInfoProviderAdapter(PullDirection pullDirection)
+        {
+            _refreshPullDirection = pullDirection;
+        }
+
+        public RefreshInfoProvider? AdaptFromTree(Visual root, Size? refreshVIsualizerSize)
+        {
+            if (root is ScrollViewer scrollViewer)
+            {
+                return Adapt(scrollViewer, refreshVIsualizerSize);
+            }
+            else
+            {
+                int depth = 0;
+                while (depth < MaxSearchDepth)
+                {
+                    var scroll = AdaptFromTreeRecursiveHelper(root, depth);
+
+                    if (scroll != null)
+                    {
+                        return Adapt(scroll, refreshVIsualizerSize);
+                    }
+
+                    depth++;
+                }
+            }
+
+            ScrollViewer? AdaptFromTreeRecursiveHelper(Visual root, int depth)
+            {
+                if (depth == 0)
+                {
+                    foreach (var child in root.VisualChildren)
+                    {
+                        if (child is ScrollViewer viewer)
+                        {
+                            return viewer;
+                        }
+                    }
+                }
+                else
+                {
+                    foreach (var child in root.VisualChildren)
+                    {
+                        var viewer = AdaptFromTreeRecursiveHelper(child, depth - 1);
+                        if (viewer != null)
+                        {
+                            return viewer;
+                        }
+                    }
+                }
+
+                return null;
+            }
+
+            return null;
+        }
+
+        public RefreshInfoProvider Adapt(ScrollViewer adaptee, Size? refreshVIsualizerSize)
+        {
+            if (adaptee == null)
+            {
+                throw new ArgumentNullException(nameof(adaptee), "Adaptee cannot be null");
+            }
+
+            if (_scrollViewer != null)
+            {
+                CleanUpScrollViewer();
+            }
+
+            if (_refreshInfoProvider != null && _interactionSource != null)
+            {
+                _interactionSource.RemoveHandler(Gestures.PullGestureEvent, _refreshInfoProvider.InteractingStateEntered);
+                _interactionSource.RemoveHandler(Gestures.PullGestureEndedEvent, _refreshInfoProvider.InteractingStateExited);
+            }
+
+            _refreshInfoProvider = null;
+            _scrollViewer = adaptee;
+
+            if (_scrollViewer.Content == null)
+            {
+                throw new ArgumentException(nameof(adaptee), "Adaptee's content property cannot be null.");
+            }
+
+            var content = adaptee.Content as Visual;
+
+            if (content == null)
+            {
+                throw new ArgumentException(nameof(adaptee), "Adaptee's content property must be a Visual");
+            }
+
+            if (content.GetVisualParent() == null)
+            {
+                _scrollViewer.Loaded += ScrollViewer_Loaded;
+            }
+            else
+            {
+                ScrollViewer_Loaded(null, null);
+
+                if (content.Parent is not InputElement)
+                {
+                    throw new ArgumentException(nameof(adaptee), "Adaptee's content's parent must be a InputElement");
+                }
+            }
+
+            _refreshInfoProvider = new RefreshInfoProvider(_refreshPullDirection, refreshVIsualizerSize, ElementComposition.GetElementVisual(content));
+
+            _pullGestureRecognizer = new PullGestureRecognizer(_refreshPullDirection);
+
+            if (_interactionSource != null)
+            {
+                _interactionSource.GestureRecognizers.Add(_pullGestureRecognizer);
+                _interactionSource.AddHandler(Gestures.PullGestureEvent, _refreshInfoProvider.InteractingStateEntered);
+                _interactionSource.AddHandler(Gestures.PullGestureEndedEvent, _refreshInfoProvider.InteractingStateExited);
+                _isVisualizerInteractionSourceAttached = true;
+            }
+
+            _scrollViewer.PointerPressed += ScrollViewer_PointerPressed;
+            _scrollViewer.PointerReleased += ScrollViewer_PointerReleased;
+            _scrollViewer.ScrollChanged += ScrollViewer_ScrollChanged;
+
+            return _refreshInfoProvider;
+        }
+
+        private void ScrollViewer_ScrollChanged(object? sender, ScrollChangedEventArgs e)
+        {
+            if (_isVisualizerInteractionSourceAttached && _refreshInfoProvider != null && _refreshInfoProvider.IsInteractingForRefresh)
+            {
+                if (!IsWithinOffsetThreashold())
+                {
+                    _refreshInfoProvider.IsInteractingForRefresh = false;
+                }
+            }
+        }
+
+        public void SetAnimations(RefreshVisualizer refreshVisualizer)
+        {
+            var visualizerComposition = ElementComposition.GetElementVisual(refreshVisualizer);
+            if (visualizerComposition != null)
+            {
+                var compositor = visualizerComposition.Compositor;
+
+                var offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
+                offsetAnimation.Target = "Offset";
+                offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
+                offsetAnimation.Duration = TimeSpan.FromMilliseconds(150);
+
+                var animation = compositor.CreateImplicitAnimationCollection();
+                animation["Offset"] = offsetAnimation;
+                visualizerComposition.ImplicitAnimations = animation;
+            }
+
+            if(_scrollViewer != null && _scrollViewer.Content is Visual visual)
+            {
+                var scollContentComposition = ElementComposition.GetElementVisual(visual);
+
+                if(scollContentComposition != null)
+                {
+                    var compositor = scollContentComposition.Compositor;
+
+                    var offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
+                    offsetAnimation.Target = "Offset";
+                    offsetAnimation.InsertExpressionKeyFrame(1.0f, "this.FinalValue");
+                    offsetAnimation.Duration = TimeSpan.FromMilliseconds(150);
+
+                    var animation = compositor.CreateImplicitAnimationCollection();
+                    animation["Offset"] = offsetAnimation;
+                    scollContentComposition.ImplicitAnimations = animation;
+                }
+            }
+        }
+
+        private void ScrollViewer_Loaded(object? sender, RoutedEventArgs? e)
+        {
+            var content = _scrollViewer?.Content as Visual;
+            if (content == null)
+            {
+                throw new ArgumentException(nameof(_scrollViewer), "Adaptee's content property must be a Visual");
+            }
+
+            if (content.Parent is not InputElement)
+            {
+                throw new ArgumentException(nameof(_scrollViewer), "Adaptee's content parent must be an InputElement");
+            }
+
+            MakeInteractionSource(content.Parent as InputElement);
+
+            if (_scrollViewer != null)
+            {
+                _scrollViewer.Loaded -= ScrollViewer_Loaded;
+            }
+        }
+
+        private void MakeInteractionSource(InputElement? element)
+        {
+            _interactionSource = element;
+
+            if (_pullGestureRecognizer != null && _refreshInfoProvider != null)
+            {
+                element?.GestureRecognizers.Add(_pullGestureRecognizer);
+                _interactionSource?.AddHandler(Gestures.PullGestureEvent, _refreshInfoProvider.InteractingStateEntered);
+                _interactionSource?.AddHandler(Gestures.PullGestureEndedEvent, _refreshInfoProvider.InteractingStateExited);
+                _isVisualizerInteractionSourceAttached = true;
+            }
+        }
+
+        private void ScrollViewer_PointerReleased(object? sender, PointerReleasedEventArgs e)
+        {
+            if (_refreshInfoProvider != null)
+            {
+                _refreshInfoProvider.IsInteractingForRefresh = false;
+            }
+        }
+
+        private void ScrollViewer_PointerPressed(object? sender, PointerPressedEventArgs e)
+        {
+            if (_refreshInfoProvider != null)
+            {
+                _refreshInfoProvider.PeekingMode = !IsWithinOffsetThreashold();
+            }
+        }
+
+        private bool IsWithinOffsetThreashold()
+        {
+            if (_scrollViewer != null)
+            {
+                var offset = _scrollViewer.Offset;
+
+                switch (_refreshPullDirection)
+                {
+                    case PullDirection.TopToBottom:
+                        return offset.Y < InitialOffsetThreshold;
+                    case PullDirection.LeftToRight:
+                        return offset.X < InitialOffsetThreshold;
+                    case PullDirection.RightToLeft:
+                        return offset.X > _scrollViewer.Extent.Width - _scrollViewer.Viewport.Width - InitialOffsetThreshold;
+                    case PullDirection.BottomToTop:
+                        return offset.Y > _scrollViewer.Extent.Height - _scrollViewer.Viewport.Height - InitialOffsetThreshold;
+                }
+            }
+
+            return false;
+        }
+
+        private void CleanUpScrollViewer()
+        {
+            if (_scrollViewer != null)
+            {
+                _scrollViewer.PointerPressed -= ScrollViewer_PointerPressed;
+                _scrollViewer.PointerReleased -= ScrollViewer_PointerReleased;
+                _scrollViewer.ScrollChanged -= ScrollViewer_ScrollChanged;
+            }
+        }
+    }
+}

src/Avalonia.Themes.Fluent/Accents/FluentControlResourcesDark.xaml

@@ -636,4 +636,8 @@
 
     <!-- BaseResources for ScrollViewer.xaml -->
     <SolidColorBrush x:Key="ScrollViewerScrollBarsSeparatorBackground" Color="{StaticResource SystemChromeMediumColor}" Opacity="0.9" />
+
+    <!-- BaseResources for RefreshVisualizer.xaml -->
+    <SolidColorBrush x:Key="RefreshVisualizerForeground" Color="White"/>
+    <SolidColorBrush x:Key="RefreshVisualizerBackground" Color="Transparent"/> 
 </ResourceDictionary>

src/Avalonia.Themes.Fluent/Accents/FluentControlResourcesLight.xaml

@@ -631,4 +631,8 @@
     
     <!-- Resources for ScrollViewer.xaml -->
     <SolidColorBrush x:Key="ScrollViewerScrollBarsSeparatorBackground" Color="{StaticResource SystemChromeMediumColor}" Opacity="0.9" />
-</ResourceDictionary>
+
+    <!-- BaseResources for RefreshVisualizer.xaml -->
+    <SolidColorBrush x:Key="RefreshVisualizerForeground" Color="Black"/>
+    <SolidColorBrush x:Key="RefreshVisualizerBackground" Color="Transparent"/> 
+</ResourceDictionary>

src/Avalonia.Themes.Fluent/Controls/FluentControls.xaml

@@ -68,6 +68,8 @@
                 <!--  ManagedFileChooser comes last because it uses (and overrides) styles for a multitude of other controls...the dialogs were originally UserControls, after all  -->
                 <ResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/ManagedFileChooser.xaml" />
                 <ResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/SelectableTextBlock.xaml"/>
+                <ResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/RefreshContainer.xaml" />
+                <ResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/RefreshVisualizer.xaml" />
             </ResourceDictionary.MergedDictionaries>
         </ResourceDictionary>
     </Styles.Resources>

src/Avalonia.Themes.Fluent/Controls/RefreshContainer.xaml

@@ -0,0 +1,24 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <ControlTheme x:Key="{x:Type RefreshContainer}"
+                TargetType="RefreshContainer">
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid>
+          <ContentPresenter Name="PART_ContentPresenter"
+                              Background="{TemplateBinding Background}"
+                              BorderBrush="{TemplateBinding BorderBrush}"
+                              BorderThickness="{TemplateBinding BorderThickness}"
+                              CornerRadius="{TemplateBinding CornerRadius}"
+                              ContentTemplate="{TemplateBinding ContentTemplate}"
+                              Content="{TemplateBinding Content}"
+                              Padding="{TemplateBinding Padding}"
+                              VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
+                              HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}">
+          </ContentPresenter>
+          <Grid Name="PART_RefreshVisualizerPresenter"/>
+        </Grid>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+</ResourceDictionary>

src/Avalonia.Themes.Fluent/Controls/RefreshVisualizer.xaml

@@ -0,0 +1,29 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <ControlTheme x:Key="{x:Type RefreshVisualizer}"
+                TargetType="RefreshVisualizer">
+    <Setter Property="IsTabStop" Value="False"/>
+    <Setter Property="IsHitTestVisible" Value="False"/>
+    <Setter Property="Height"
+            Value="100"/>
+    <Setter Property="Background"
+            Value="{DynamicResource RefreshVisualizerBackground}"/>
+    <Setter Property="Foreground"
+            Value="{DynamicResource RefreshVisualizerForeground}"/>
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid Name="PART_Root"
+              MinHeight="80"
+              Background="{TemplateBinding Background}">
+          <Grid.Styles>
+            <Style Selector="PathIcon#PART_Icon">
+              <Setter Property="Data"
+                      Value="M18.6195264,3.31842271 C19.0080059,3.31842271 19.3290603,3.60710385 19.3798716,3.9816481 L19.3868766,4.08577298 L19.3868766,6.97963208 C19.3868766,7.36811161 19.0981955,7.68916605 18.7236513,7.73997735 L18.6195264,7.74698235 L15.7256673,7.74698235 C15.3018714,7.74698235 14.958317,7.40342793 14.958317,6.97963208 C14.958317,6.59115255 15.2469981,6.27009811 15.6215424,6.21928681 L15.7256673,6.21228181 L16.7044011,6.21182461 C13.7917384,3.87107476 9.52212532,4.05209336 6.81933829,6.75488039 C3.92253872,9.65167996 3.92253872,14.34832 6.81933829,17.2451196 C9.71613786,20.1419192 14.4127779,20.1419192 17.3095775,17.2451196 C19.0725398,15.4821573 19.8106555,12.9925923 19.3476248,10.58925 C19.2674502,10.173107 19.5398064,9.77076216 19.9559494,9.69058758 C20.3720923,9.610413 20.7744372,9.88276918 20.8546118,10.2989121 C21.4129973,13.1971899 20.5217103,16.2033812 18.3947747,18.3303168 C14.8986373,21.8264542 9.23027854,21.8264542 5.73414113,18.3303168 C2.23800371,14.8341794 2.23800371,9.16582064 5.73414113,5.66968323 C9.05475132,2.34907304 14.3349409,2.18235834 17.8523166,5.16953912 L17.8521761,4.08577298 C17.8521761,3.66197713 18.1957305,3.31842271 18.6195264,3.31842271 Z">
+              </Setter>
+            </Style>
+          </Grid.Styles>
+        </Grid>      
+    </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+</ResourceDictionary>

src/Avalonia.Themes.Simple/Accents/BaseDark.xaml

@@ -31,5 +31,8 @@
         <SolidColorBrush x:Key="ThemeControlHighlightHighBrush" Color="{StaticResource ThemeControlHighlightHighColor}" />
         <SolidColorBrush x:Key="ThemeForegroundBrush" Color="{StaticResource ThemeForegroundColor}" />
         <SolidColorBrush x:Key="HighlightBrush" Color="{StaticResource HighlightColor}" />
+      
+        <SolidColorBrush x:Key="RefreshVisualizerForeground" Color="White"/>
+        <SolidColorBrush x:Key="RefreshVisualizerBackground" Color="Transparent"/>
 
 </ResourceDictionary>

src/Avalonia.Themes.Simple/Accents/BaseLight.xaml

@@ -31,5 +31,7 @@
         <SolidColorBrush x:Key="ThemeControlHighlightHighBrush" Color="{StaticResource ThemeControlHighlightHighColor}" />
         <SolidColorBrush x:Key="ThemeForegroundBrush" Color="{StaticResource ThemeForegroundColor}" />
 
-        <SolidColorBrush x:Key="HighlightBrush" Color="{StaticResource HighlightColor}" />
+        <SolidColorBrush x:Key="HighlightBrush" Color="{StaticResource HighlightColor}" />      
+        <SolidColorBrush x:Key="RefreshVisualizerForeground" Color="Black"/>
+        <SolidColorBrush x:Key="RefreshVisualizerBackground" Color="Transparent"/>
 </ResourceDictionary>

src/Avalonia.Themes.Simple/Controls/RefreshContainer.xaml

@@ -0,0 +1,24 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <ControlTheme x:Key="{x:Type RefreshContainer}"
+                TargetType="RefreshContainer">
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid>
+          <ContentPresenter Name="PART_ContentPresenter"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            CornerRadius="{TemplateBinding CornerRadius}"
+                            ContentTemplate="{TemplateBinding ContentTemplate}"
+                            Content="{TemplateBinding Content}"
+                            Padding="{TemplateBinding Padding}"
+                            VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
+                            HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}">
+          </ContentPresenter>
+          <Grid Name="PART_RefreshVisualizerPresenter"/>
+        </Grid>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+</ResourceDictionary>

src/Avalonia.Themes.Simple/Controls/RefreshVisualizer.xaml

@@ -0,0 +1,31 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+  <ControlTheme x:Key="{x:Type RefreshVisualizer}"
+                TargetType="RefreshVisualizer">
+    <Setter Property="IsTabStop"
+            Value="False"/>
+    <Setter Property="IsHitTestVisible"
+            Value="False"/>
+    <Setter Property="Height"
+            Value="100"/>
+    <Setter Property="Background"
+            Value="{DynamicResource RefreshVisualizerBackground}"/>
+    <Setter Property="Foreground"
+            Value="{DynamicResource RefreshVisualizerForeground}"/>
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid Name="PART_Root"
+              MinHeight="80"
+              Background="{TemplateBinding Background}">
+          <Grid.Styles>
+            <Style Selector="PathIcon#PART_Icon">
+              <Setter Property="Data"
+                      Value="M18.6195264,3.31842271 C19.0080059,3.31842271 19.3290603,3.60710385 19.3798716,3.9816481 L19.3868766,4.08577298 L19.3868766,6.97963208 C19.3868766,7.36811161 19.0981955,7.68916605 18.7236513,7.73997735 L18.6195264,7.74698235 L15.7256673,7.74698235 C15.3018714,7.74698235 14.958317,7.40342793 14.958317,6.97963208 C14.958317,6.59115255 15.2469981,6.27009811 15.6215424,6.21928681 L15.7256673,6.21228181 L16.7044011,6.21182461 C13.7917384,3.87107476 9.52212532,4.05209336 6.81933829,6.75488039 C3.92253872,9.65167996 3.92253872,14.34832 6.81933829,17.2451196 C9.71613786,20.1419192 14.4127779,20.1419192 17.3095775,17.2451196 C19.0725398,15.4821573 19.8106555,12.9925923 19.3476248,10.58925 C19.2674502,10.173107 19.5398064,9.77076216 19.9559494,9.69058758 C20.3720923,9.610413 20.7744372,9.88276918 20.8546118,10.2989121 C21.4129973,13.1971899 20.5217103,16.2033812 18.3947747,18.3303168 C14.8986373,21.8264542 9.23027854,21.8264542 5.73414113,18.3303168 C2.23800371,14.8341794 2.23800371,9.16582064 5.73414113,5.66968323 C9.05475132,2.34907304 14.3349409,2.18235834 17.8523166,5.16953912 L17.8521761,4.08577298 C17.8521761,3.66197713 18.1957305,3.31842271 18.6195264,3.31842271 Z">
+              </Setter>
+            </Style>
+          </Grid.Styles>
+        </Grid>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+</ResourceDictionary>

src/Avalonia.Themes.Simple/Controls/SimpleControls.xaml

@@ -65,6 +65,8 @@
         <ResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/ManagedFileChooser.xaml" />
         <ResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/SplitButton.xaml" />
         <ResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/SelectableTextBlock.xaml" />
+        <ResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/RefreshContainer.xaml" />
+        <ResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/RefreshVisualizer.xaml" />
       </ResourceDictionary.MergedDictionaries>
     </ResourceDictionary>
   </Styles.Resources>

tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs

@@ -1,5 +1,7 @@
+using System;
 using Avalonia.Controls;
 using Avalonia.Input;
+using Avalonia.Interactivity;
 using Avalonia.UnitTests;
 using Xunit;
 
@@ -25,6 +27,33 @@ namespace Avalonia.Base.UnitTests.Input
             }
         }
 
+        [Fact]
+        public void Focus_Should_Not_Get_Restored_To_Enabled_Control()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var sp = new StackPanel();
+                Button target = new Button();
+                Button target1 = new Button();
+                target.Click += (s, e) => target.IsEnabled = false;
+                target1.Click += (s, e) => target.IsEnabled = true;
+                sp.Children.Add(target);
+                sp.Children.Add(target1);
+                var root = new TestRoot
+                {
+                    Child = sp
+                };
+
+                target.Focus();
+                target.RaiseEvent(new RoutedEventArgs(AccessKeyHandler.AccessKeyPressedEvent));
+                Assert.False(target.IsEnabled);
+                Assert.False(target.IsFocused);
+                target1.RaiseEvent(new RoutedEventArgs(AccessKeyHandler.AccessKeyPressedEvent));
+                Assert.True(target.IsEnabled);
+                Assert.False(target.IsFocused);
+            }
+        }
+
         [Fact]
         public void Focus_Should_Be_Cleared_When_Control_Is_Removed_From_VisualTree()
         {

tests/Avalonia.Controls.UnitTests/TextBoxTests.cs

@@ -59,6 +59,28 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void TextBox_Should_Lose_Focus_When_Disabled()
+        {
+            using (UnitTestApplication.Start(FocusServices))
+            {
+                var target = new TextBox
+                {
+                    Template = CreateTemplate()
+                };
+
+                target.ApplyTemplate();
+
+                var root = new TestRoot() { Child = target };
+
+                target.Focus();
+                Assert.True(target.IsFocused);
+                target.IsEnabled = false;
+                Assert.False(target.IsFocused);
+                Assert.False(target.IsEnabled);
+            }
+        }
+
         [Fact]
         public void Opening_Context_Flyout_Does_not_Lose_Selection()
         {