Max Katz
3 years ago
committed by
GitHub
GitHub
173 changed files with 2903 additions and 439 deletions
@ -0,0 +1,5 @@ |
|||
<ProjectConfiguration> |
|||
<Settings> |
|||
<IgnoreThisComponentCompletely>True</IgnoreThisComponentCompletely> |
|||
</Settings> |
|||
</ProjectConfiguration> |
|||
@ -0,0 +1,16 @@ |
|||
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<PropertyGroup> |
|||
<SuppressTrimAnalysisWarnings>false</SuppressTrimAnalysisWarnings> |
|||
<EnableTrimAnalyzer>true</EnableTrimAnalyzer> |
|||
<TrimmerSingleWarn>false</TrimmerSingleWarn> |
|||
<IsTrimmable>true</IsTrimmable> |
|||
</PropertyGroup> |
|||
<!-- Remove check for the AOT when we get rid of dependencies with reflection --> |
|||
<PropertyGroup Condition="'$(TargetFramework)' != 'netstandard2.0' and '$(PublishAot)' != 'true'"> |
|||
<ILLinkTreatWarningsAsErrors>true</ILLinkTreatWarningsAsErrors> |
|||
<!-- Trim warnings --> |
|||
<WarningsAsErrors>$(WarningsAsErrors);IL2000;IL2001;IL2002;IL2003;IL2004;IL2005;IL2006;IL2007;IL2008;IL2009;IL2010;IL2011;IL2012;IL2013;IL2014;IL2015;IL2016;IL2017;IL2018;IL2019;IL2020;IL2021;IL2022;IL2023;IL2024;IL2025;IL2026;IL2027;IL2028;IL2029;IL2030;IL2031;IL2032;IL2033;IL2034;IL2035;IL2036;IL2037;IL2038;IL2039;IL2040;IL2041;IL2042;IL2043;IL2044;IL2045;IL2046;IL2047;IL2048;IL2049;IL2050;IL2051;IL2052;IL2053;IL2054;IL2055;IL2056;IL2057;IL2058;IL2059;IL2060;IL2061;IL2062;IL2063;IL2064;IL2065;IL2066;IL2067;IL2068;IL2069;IL2070;IL2071;IL2072;IL2073;IL2074;IL2075;IL2076;IL2077;IL2078;IL2079;IL2080;IL2081;IL2082;IL2083;IL2084;IL2085;IL2086;IL2087;IL2088;IL2089;IL2090;IL2091;IL2092;IL2093;IL2094;IL2095;IL2096;IL2097;IL2098;IL2099;IL2100;IL2101;IL2102;IL2103;IL2104;IL2105;IL2106;IL2107;IL2108;IL2109;IL2110;IL2111;IL2112;IL2113;IL2114;IL2115;IL2116;IL2117;IL2118;IL2119;IL2120;IL2121;IL2122;IL2123;IL2124;IL2125;IL2126;IL2127;IL2128;IL2129;IL2130;IL2131;IL2132;IL2133;IL2134;IL2135;IL2136;IL2137;IL2138;IL2139;IL2140;IL2141;IL2142;IL2143;IL2144;IL2145;IL2146;IL2147;IL2148;IL2149;IL2150;IL2151;IL2152;IL2153;IL2154;IL2155;IL2156;IL2157</WarningsAsErrors> |
|||
<!-- NativeAOT warnings --> |
|||
<WarningsAsErrors>$(WarningsAsErrors);IL3050;IL3051;IL3052;IL3053;IL3054;IL3055;IL3056</WarningsAsErrors> |
|||
</PropertyGroup> |
|||
</Project> |
|||
@ -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> |
|||
@ -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); |
|||
} |
|||
} |
|||
} |
|||
@ -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}"); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,8 @@ |
|||
<Application |
|||
xmlns="https://github.com/avaloniaui" |
|||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
|||
x:Class="ReactiveUIDemo.App"> |
|||
<Application.Styles> |
|||
<FluentTheme /> |
|||
</Application.Styles> |
|||
</Application> |
|||
@ -0,0 +1,37 @@ |
|||
using Avalonia; |
|||
using Avalonia.Controls.ApplicationLifetimes; |
|||
using Avalonia.Markup.Xaml; |
|||
using Avalonia.ReactiveUI; |
|||
using ReactiveUI; |
|||
using ReactiveUIDemo.ViewModels; |
|||
using ReactiveUIDemo.Views; |
|||
using Splat; |
|||
|
|||
namespace ReactiveUIDemo |
|||
{ |
|||
public class App : Application |
|||
{ |
|||
public override void Initialize() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
Locator.CurrentMutable.Register(() => new FooView(), typeof(IViewFor<FooViewModel>)); |
|||
Locator.CurrentMutable.Register(() => new BarView(), typeof(IViewFor<BarViewModel>)); |
|||
} |
|||
|
|||
public override void OnFrameworkInitializationCompleted() |
|||
{ |
|||
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop) |
|||
desktop.MainWindow = new MainWindow(); |
|||
base.OnFrameworkInitializationCompleted(); |
|||
} |
|||
|
|||
public static int Main(string[] args) |
|||
=> BuildAvaloniaApp().StartWithClassicDesktopLifetime(args); |
|||
|
|||
public static AppBuilder BuildAvaloniaApp() |
|||
=> AppBuilder.Configure<App>() |
|||
.UsePlatformDetect() |
|||
.UseReactiveUI() |
|||
.LogToTrace(); |
|||
} |
|||
} |
|||
@ -0,0 +1,19 @@ |
|||
<Window xmlns="https://github.com/avaloniaui" |
|||
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' |
|||
x:Class="ReactiveUIDemo.MainWindow" |
|||
xmlns:vm="using:ReactiveUIDemo.ViewModels" |
|||
xmlns:rxui="using:Avalonia.ReactiveUI" |
|||
Title="AvaloniaUI ReactiveUI Demo" |
|||
x:DataType="vm:MainWindowViewModel"> |
|||
<TabControl TabStripPlacement="Left"> |
|||
<TabItem Header="RoutedViewHost"> |
|||
<DockPanel DataContext="{Binding RoutedViewHost}"> |
|||
<StackPanel DockPanel.Dock="Bottom" Orientation="Horizontal" Spacing="8"> |
|||
<Button Command="{Binding ShowFoo}">Foo</Button> |
|||
<Button Command="{Binding ShowBar}">Bar</Button> |
|||
</StackPanel> |
|||
<rxui:RoutedViewHost Router="{Binding Router}"/> |
|||
</DockPanel> |
|||
</TabItem> |
|||
</TabControl> |
|||
</Window> |
|||
@ -0,0 +1,22 @@ |
|||
using ReactiveUIDemo.ViewModels; |
|||
using Avalonia; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Markup.Xaml; |
|||
|
|||
namespace ReactiveUIDemo |
|||
{ |
|||
public class MainWindow : Window |
|||
{ |
|||
public MainWindow() |
|||
{ |
|||
this.InitializeComponent(); |
|||
this.DataContext = new MainWindowViewModel(); |
|||
this.AttachDevTools(); |
|||
} |
|||
|
|||
private void InitializeComponent() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
<PropertyGroup> |
|||
<OutputType>Exe</OutputType> |
|||
<TargetFramework>net6.0</TargetFramework> |
|||
<Nullable>enable</Nullable> |
|||
</PropertyGroup> |
|||
|
|||
<ItemGroup> |
|||
<ProjectReference Include="..\..\src\Avalonia.Diagnostics\Avalonia.Diagnostics.csproj" /> |
|||
<ProjectReference Include="..\..\src\Avalonia.ReactiveUI\Avalonia.ReactiveUI.csproj" /> |
|||
<ProjectReference Include="..\..\src\Avalonia.Themes.Fluent\Avalonia.Themes.Fluent.csproj" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Compile Update="Views\BarView.axaml.cs"> |
|||
<DependentUpon>BarView.axaml</DependentUpon> |
|||
</Compile> |
|||
<Compile Update="Views\FooView.axaml.cs"> |
|||
<DependentUpon>FooView.axaml</DependentUpon> |
|||
</Compile> |
|||
</ItemGroup> |
|||
|
|||
<Import Project="..\..\build\SampleApp.props" /> |
|||
<Import Project="..\..\build\ReferenceCoreLibraries.props" /> |
|||
<Import Project="..\..\build\BuildTargets.targets" /> |
|||
<Import Project="..\..\build\Rx.props" /> |
|||
<Import Project="..\..\build\ReactiveUI.props" /> |
|||
</Project> |
|||
@ -0,0 +1,11 @@ |
|||
using ReactiveUI; |
|||
|
|||
namespace ReactiveUIDemo.ViewModels |
|||
{ |
|||
internal class BarViewModel : ReactiveObject, IRoutableViewModel |
|||
{ |
|||
public BarViewModel(IScreen screen) => HostScreen = screen; |
|||
public string UrlPathSegment => "Bar"; |
|||
public IScreen HostScreen { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,11 @@ |
|||
using ReactiveUI; |
|||
|
|||
namespace ReactiveUIDemo.ViewModels |
|||
{ |
|||
internal class FooViewModel : ReactiveObject, IRoutableViewModel |
|||
{ |
|||
public FooViewModel(IScreen screen) => HostScreen = screen; |
|||
public string UrlPathSegment => "Foo"; |
|||
public IScreen HostScreen { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,9 @@ |
|||
using ReactiveUI; |
|||
|
|||
namespace ReactiveUIDemo.ViewModels |
|||
{ |
|||
internal class MainWindowViewModel : ReactiveObject |
|||
{ |
|||
public RoutedViewHostPageViewModel RoutedViewHost { get; } = new(); |
|||
} |
|||
} |
|||
@ -0,0 +1,21 @@ |
|||
using ReactiveUI; |
|||
|
|||
namespace ReactiveUIDemo.ViewModels |
|||
{ |
|||
internal class RoutedViewHostPageViewModel : ReactiveObject, IScreen |
|||
{ |
|||
public RoutedViewHostPageViewModel() |
|||
{ |
|||
Foo = new(this); |
|||
Bar = new(this); |
|||
Router.Navigate.Execute(Foo); |
|||
} |
|||
|
|||
public RoutingState Router { get; } = new(); |
|||
public FooViewModel Foo { get; } |
|||
public BarViewModel Bar { get; } |
|||
|
|||
public void ShowFoo() => Router.Navigate.Execute(Foo); |
|||
public void ShowBar() => Router.Navigate.Execute(Bar); |
|||
} |
|||
} |
|||
@ -0,0 +1,16 @@ |
|||
<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" |
|||
mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450" |
|||
x:Class="ReactiveUIDemo.Views.BarView" |
|||
HorizontalAlignment="Stretch" |
|||
VerticalAlignment="Stretch"> |
|||
<Border Background="Blue"> |
|||
<TextBlock HorizontalAlignment="Center" |
|||
VerticalAlignment="Center" |
|||
FontSize="48"> |
|||
Bar! |
|||
</TextBlock> |
|||
</Border> |
|||
</UserControl> |
|||
@ -0,0 +1,28 @@ |
|||
using Avalonia.Controls; |
|||
using Avalonia.Markup.Xaml; |
|||
using ReactiveUI; |
|||
using ReactiveUIDemo.ViewModels; |
|||
|
|||
namespace ReactiveUIDemo.Views |
|||
{ |
|||
internal partial class BarView : UserControl, IViewFor<BarViewModel> |
|||
{ |
|||
public BarView() |
|||
{ |
|||
InitializeComponent(); |
|||
} |
|||
|
|||
public BarViewModel? ViewModel { get; set; } |
|||
|
|||
object? IViewFor.ViewModel |
|||
{ |
|||
get => ViewModel; |
|||
set => ViewModel = (BarViewModel?)value; |
|||
} |
|||
|
|||
private void InitializeComponent() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,16 @@ |
|||
<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" |
|||
mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450" |
|||
x:Class="ReactiveUIDemo.Views.FooView" |
|||
HorizontalAlignment="Stretch" |
|||
VerticalAlignment="Stretch"> |
|||
<Border Background="Red"> |
|||
<TextBlock HorizontalAlignment="Center" |
|||
VerticalAlignment="Center" |
|||
FontSize="48"> |
|||
Foo! |
|||
</TextBlock> |
|||
</Border> |
|||
</UserControl> |
|||
@ -0,0 +1,28 @@ |
|||
using Avalonia.Controls; |
|||
using Avalonia.Markup.Xaml; |
|||
using ReactiveUI; |
|||
using ReactiveUIDemo.ViewModels; |
|||
|
|||
namespace ReactiveUIDemo.Views |
|||
{ |
|||
internal partial class FooView : UserControl, IViewFor<FooViewModel> |
|||
{ |
|||
public FooView() |
|||
{ |
|||
InitializeComponent(); |
|||
} |
|||
|
|||
public FooViewModel? ViewModel { get; set; } |
|||
|
|||
object? IViewFor.ViewModel |
|||
{ |
|||
get => ViewModel; |
|||
set => ViewModel = (FooViewModel?)value; |
|||
} |
|||
|
|||
private void InitializeComponent() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,121 @@ |
|||
#pragma warning disable MA0048 // File name must match type name
|
|||
// https://github.com/dotnet/runtime/tree/main/src/libraries/System.Private.CoreLib/src/System/Diagnostics/CodeAnalysis
|
|||
|
|||
// Licensed to the .NET Foundation under one or more agreements.
|
|||
// The .NET Foundation licenses this file to you under the MIT license.
|
|||
// See the LICENSE file in the project root for more information.
|
|||
|
|||
namespace System.Diagnostics.CodeAnalysis |
|||
{ |
|||
#nullable enable |
|||
#if !NET6_0_OR_GREATER
|
|||
[AttributeUsage( |
|||
AttributeTargets.Field | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter | |
|||
AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Method | |
|||
AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct, |
|||
Inherited = false)] |
|||
internal sealed class DynamicallyAccessedMembersAttribute : Attribute |
|||
{ |
|||
public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes) |
|||
{ |
|||
MemberTypes = memberTypes; |
|||
} |
|||
|
|||
public DynamicallyAccessedMemberTypes MemberTypes { get; } |
|||
} |
|||
|
|||
[Flags] |
|||
internal enum DynamicallyAccessedMemberTypes |
|||
{ |
|||
None = 0, |
|||
PublicParameterlessConstructor = 0x0001, |
|||
PublicConstructors = 0x0002 | PublicParameterlessConstructor, |
|||
NonPublicConstructors = 0x0004, |
|||
PublicMethods = 0x0008, |
|||
NonPublicMethods = 0x0010, |
|||
PublicFields = 0x0020, |
|||
NonPublicFields = 0x0040, |
|||
PublicNestedTypes = 0x0080, |
|||
NonPublicNestedTypes = 0x0100, |
|||
PublicProperties = 0x0200, |
|||
NonPublicProperties = 0x0400, |
|||
PublicEvents = 0x0800, |
|||
NonPublicEvents = 0x1000, |
|||
Interfaces = 0x2000, |
|||
All = ~None |
|||
} |
|||
|
|||
[AttributeUsage( |
|||
AttributeTargets.Constructor | AttributeTargets.Field | AttributeTargets.Method, |
|||
AllowMultiple = true, Inherited = false)] |
|||
internal sealed class DynamicDependencyAttribute : Attribute |
|||
{ |
|||
public DynamicDependencyAttribute(string memberSignature) |
|||
{ |
|||
MemberSignature = memberSignature; |
|||
} |
|||
|
|||
public DynamicDependencyAttribute(string memberSignature, Type type) |
|||
{ |
|||
MemberSignature = memberSignature; |
|||
Type = type; |
|||
} |
|||
|
|||
public DynamicDependencyAttribute(string memberSignature, string typeName, string assemblyName) |
|||
{ |
|||
MemberSignature = memberSignature; |
|||
TypeName = typeName; |
|||
AssemblyName = assemblyName; |
|||
} |
|||
|
|||
public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, Type type) |
|||
{ |
|||
MemberTypes = memberTypes; |
|||
Type = type; |
|||
} |
|||
|
|||
public DynamicDependencyAttribute(DynamicallyAccessedMemberTypes memberTypes, string typeName, string assemblyName) |
|||
{ |
|||
MemberTypes = memberTypes; |
|||
TypeName = typeName; |
|||
AssemblyName = assemblyName; |
|||
} |
|||
|
|||
public string? MemberSignature { get; } |
|||
public DynamicallyAccessedMemberTypes MemberTypes { get; } |
|||
public Type? Type { get; } |
|||
public string? TypeName { get; } |
|||
public string? AssemblyName { get; } |
|||
public string? Condition { get; set; } |
|||
} |
|||
|
|||
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | AttributeTargets.Class, Inherited = false)] |
|||
internal sealed class RequiresUnreferencedCodeAttribute : Attribute |
|||
{ |
|||
public RequiresUnreferencedCodeAttribute(string message) |
|||
{ |
|||
Message = message; |
|||
} |
|||
|
|||
public string Message { get; } |
|||
public string? Url { get; set; } |
|||
} |
|||
|
|||
[AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)] |
|||
internal sealed class UnconditionalSuppressMessageAttribute : Attribute |
|||
{ |
|||
public UnconditionalSuppressMessageAttribute(string category, string checkId) |
|||
{ |
|||
Category = category; |
|||
CheckId = checkId; |
|||
} |
|||
public string Category { get; } |
|||
public string CheckId { get; } |
|||
public string? Scope { get; set; } |
|||
public string? Target { get; set; } |
|||
public string? MessageId { get; set; } |
|||
public string? Justification { get; set; } |
|||
} |
|||
#endif
|
|||
} |
|||
|
|||
@ -0,0 +1,30 @@ |
|||
namespace Avalonia; |
|||
|
|||
internal static class TrimmingMessages |
|||
{ |
|||
public const string ImplicitTypeConvertionSupressWarningMessage = "Implicit convertion methods might be removed by the linker. We don't have a reliable way to prevent it, except converting everything in compile time when possible."; |
|||
public const string ImplicitTypeConvertionRequiresUnreferencedCodeMessage = "Implicit convertion methods are required for type conversion."; |
|||
|
|||
public const string TypeConvertionSupressWarningMessage = "Convertion methods might be removed by the linker. We don't have a reliable way to prevent it, except converting everything in compile time when possible."; |
|||
public const string TypeConvertionRequiresUnreferencedCodeMessage = "Convertion methods are required for type conversion, including op_Implicit, op_Explicit, Parse and TypeConverter."; |
|||
|
|||
public const string ReflectionBindingRequiresUnreferencedCodeMessage = "BindingExpression and ReflectionBinding heavily use reflection. Consider using CompiledBindings instead."; |
|||
public const string ReflectionBindingSupressWarningMessage = "BindingExpression and ReflectionBinding internal heavily use reflection."; |
|||
|
|||
public const string CompiledBindingSafeSupressWarningMessage = "CompiledBinding preserves members used in the expression tree."; |
|||
|
|||
public const string ExpressionNodeRequiresUnreferencedCodeMessage = "ExpressionNode might require unreferenced code."; |
|||
public const string ExpressionSafeSupressWarningMessage = "Typed Expressions preserves members used in the expression tree."; |
|||
|
|||
public const string SelectorsParseRequiresUnreferencedCodeMessage = "Selectors runtime parser might require unreferenced code. Consider using stronly typed selectors factory with 'new Style(s => s.OfType<Button>())' syntax."; |
|||
|
|||
public const string PropertyAccessorsRequiresUnreferencedCodeMessage = "PropertyAccessors might require unreferenced code."; |
|||
public const string DataValidationPluginRequiresUnreferencedCodeMessage = "DataValidationPlugin might require unreferenced code."; |
|||
public const string StreamPluginRequiresUnreferencedCodeMessage = "StreamPlugin might require unreferenced code."; |
|||
|
|||
public const string StyleResourceIncludeRequiresUnreferenceCodeMessage = "StyleInclude and ResourceInclude use AvaloniaXamlLoader.Load which dynamically loads referenced assembly with Avalonia resources. Note, StyleInclude and ResourceInclude defined in XAML are resolved compile time and are safe with trimming and AOT."; |
|||
public const string AvaloniaXamlLoaderRequiresUnreferenceCodeMessage = "AvaloniaXamlLoader.Load(uri, baseUri) dynamically loads referenced assembly with Avalonia resources."; |
|||
public const string XamlTypeResolvedRequiresUnreferenceCodeMessage = "XamlTypeResolver might require unreferenced code."; |
|||
|
|||
public const string IgnoreNativeAotSupressWarningMessage = "This method is not supported by NativeAOT."; |
|||
} |
|||
@ -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)); |
|||
} |
|||
} |
|||
} |
|||
@ -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 |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
@ -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(); |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -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(); |
|||
} |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -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 |
|||
} |
|||
} |
|||
@ -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 |
|||
} |
|||
} |
|||
@ -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; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue