diff --git a/src/Avalonia.Base/Input/Gestures.cs b/src/Avalonia.Base/Input/Gestures.cs
index b4d5feaf3b..54e61d89b2 100644
--- a/src/Avalonia.Base/Input/Gestures.cs
+++ b/src/Avalonia.Base/Input/Gestures.cs
@@ -1,6 +1,8 @@
using System;
+using System.Threading;
using Avalonia.Interactivity;
using Avalonia.Platform;
+using Avalonia.Threading;
using Avalonia.VisualTree;
namespace Avalonia.Input
@@ -8,6 +10,21 @@ namespace Avalonia.Input
public static class Gestures
{
private static bool s_isDoubleTapped = false;
+ private static bool s_isHolding;
+ private static CancellationTokenSource? s_holdCancellationToken;
+
+ ///
+ /// Defines the IsHoldingEnabled attached property.
+ ///
+ public static readonly AttachedProperty IsHoldingEnabledProperty =
+ AvaloniaProperty.RegisterAttached("IsHoldingEnabled", typeof(Gestures), true);
+
+ ///
+ /// Defines the IsHoldWithMouseEnabled attached property.
+ ///
+ public static readonly AttachedProperty IsHoldWithMouseEnabledProperty =
+ AvaloniaProperty.RegisterAttached("IsHoldWithMouseEnabled", typeof(Gestures), false);
+
public static readonly RoutedEvent TappedEvent = RoutedEvent.Register(
"Tapped",
RoutingStrategies.Bubble,
@@ -45,6 +62,7 @@ namespace Avalonia.Input
private static readonly WeakReference s_lastPress = new WeakReference(null);
private static Point s_lastPressPoint;
+ private static IPointer? s_lastPointer;
public static readonly RoutedEvent PinchEvent =
RoutedEvent.Register(
@@ -58,14 +76,40 @@ namespace Avalonia.Input
RoutedEvent.Register(
"PullGesture", RoutingStrategies.Bubble, typeof(Gestures));
+ ///
+ /// Occurs when a user performs a press and hold gesture (with a single touch, mouse, or pen/stylus contact).
+ ///
+ public static readonly RoutedEvent HoldingEvent =
+ RoutedEvent.Register(
+ "Holding", RoutingStrategies.Bubble, typeof(Gestures));
+
public static readonly RoutedEvent PullGestureEndedEvent =
RoutedEvent.Register(
"PullGestureEnded", RoutingStrategies.Bubble, typeof(Gestures));
+ public static bool GetIsHoldingEnabled(StyledElement element)
+ {
+ return element.GetValue(IsHoldingEnabledProperty);
+ }
+ public static void SetIsHoldingEnabled(StyledElement element, bool value)
+ {
+ element.SetValue(IsHoldingEnabledProperty, value);
+ }
+
+ public static bool GetIsHoldWithMouseEnabled(StyledElement element)
+ {
+ return element.GetValue(IsHoldWithMouseEnabledProperty);
+ }
+ public static void SetIsHoldWithMouseEnabled(StyledElement element, bool value)
+ {
+ element.SetValue(IsHoldWithMouseEnabledProperty, value);
+ }
+
static Gestures()
{
InputElement.PointerPressedEvent.RouteFinished.Subscribe(PointerPressed);
InputElement.PointerReleasedEvent.RouteFinished.Subscribe(PointerReleased);
+ InputElement.PointerMovedEvent.RouteFinished.Subscribe(PointerMoved);
}
public static void AddTappedHandler(Interactive element, EventHandler handler)
@@ -110,11 +154,42 @@ namespace Avalonia.Input
var e = (PointerPressedEventArgs)ev;
var visual = (Visual)ev.Source;
+ if(s_lastPointer != null)
+ {
+ if(s_isHolding && ev.Source is Interactive i)
+ {
+ i.RaiseEvent(new HoldingRoutedEventArgs(HoldingState.Cancelled, s_lastPressPoint, s_lastPointer.Type));
+ }
+ s_holdCancellationToken?.Cancel();
+ s_holdCancellationToken?.Dispose();
+ s_holdCancellationToken = null;
+
+ s_lastPointer = null;
+ }
+
+ s_isHolding = false;
+
if (e.ClickCount % 2 == 1)
{
s_isDoubleTapped = false;
s_lastPress.SetTarget(ev.Source);
+ s_lastPointer = e.Pointer;
s_lastPressPoint = e.GetPosition((Visual)ev.Source);
+ s_holdCancellationToken = new CancellationTokenSource();
+ var token = s_holdCancellationToken.Token;
+ var settings = AvaloniaLocator.Current.GetService();
+
+ if (settings != null)
+ {
+ DispatcherTimer.RunOnce(() =>
+ {
+ if (!token.IsCancellationRequested && e.Source is InputElement i && GetIsHoldingEnabled(i) && (e.Pointer.Type != PointerType.Mouse || GetIsHoldWithMouseEnabled(i)))
+ {
+ s_isHolding = true;
+ i.RaiseEvent(new HoldingRoutedEventArgs(HoldingState.Started, s_lastPressPoint, s_lastPointer.Type));
+ }
+ }, settings.HoldWaitDuration);
+ }
}
else if (e.ClickCount % 2 == 0 && e.GetCurrentPoint(visual).Properties.IsLeftButtonPressed)
{
@@ -148,7 +223,12 @@ namespace Avalonia.Input
if (tapRect.ContainsExclusive(point.Position))
{
- if (e.InitialPressMouseButton == MouseButton.Right)
+ if(s_isHolding)
+ {
+ s_isHolding = false;
+ i.RaiseEvent(new HoldingRoutedEventArgs(HoldingState.Completed, s_lastPressPoint, s_lastPointer!.Type));
+ }
+ else if (e.InitialPressMouseButton == MouseButton.Right)
{
i.RaiseEvent(new TappedEventArgs(RightTappedEvent, e));
}
@@ -160,6 +240,45 @@ namespace Avalonia.Input
}
}
}
+
+ s_holdCancellationToken?.Cancel();
+ s_holdCancellationToken?.Dispose();
+ s_holdCancellationToken = null;
+ s_lastPointer = null;
+ }
+ }
+
+ private static void PointerMoved(RoutedEventArgs ev)
+ {
+ if (ev.Route == RoutingStrategies.Bubble)
+ {
+ var e = (PointerEventArgs)ev;
+ if (s_lastPress.TryGetTarget(out var target))
+ {
+ if (e.Pointer == s_lastPointer)
+ {
+ var point = e.GetCurrentPoint((Visual)target);
+ var settings = AvaloniaLocator.Current.GetService();
+ var tapSize = settings?.GetTapSize(point.Pointer.Type) ?? new Size(4, 4);
+ var tapRect = new Rect(s_lastPressPoint, new Size())
+ .Inflate(new Thickness(tapSize.Width, tapSize.Height));
+
+ if (tapRect.ContainsExclusive(point.Position))
+ {
+ return;
+ }
+
+ if (s_isHolding && ev.Source is Interactive i)
+ {
+ i.RaiseEvent(new HoldingRoutedEventArgs(HoldingState.Cancelled, s_lastPressPoint, s_lastPointer!.Type));
+ }
+ }
+ }
+
+ s_holdCancellationToken?.Cancel();
+ s_holdCancellationToken?.Dispose();
+ s_holdCancellationToken = null;
+ s_isHolding = false;
}
}
}
diff --git a/src/Avalonia.Base/Input/HoldingRoutedEventArgs.cs b/src/Avalonia.Base/Input/HoldingRoutedEventArgs.cs
new file mode 100644
index 0000000000..b9a877b2ed
--- /dev/null
+++ b/src/Avalonia.Base/Input/HoldingRoutedEventArgs.cs
@@ -0,0 +1,51 @@
+using System;
+using Avalonia.Interactivity;
+
+namespace Avalonia.Input
+{
+ public class HoldingRoutedEventArgs : RoutedEventArgs
+ {
+ ///
+ /// Gets the state of the event.
+ ///
+ public HoldingState HoldingState { get; }
+
+ ///
+ /// Gets the location of the touch, mouse, or pen/stylus contact.
+ ///
+ public Point Position { get; }
+
+ ///
+ /// Gets the pointer type of the input source.
+ ///
+ public PointerType PointerType { get; }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public HoldingRoutedEventArgs(HoldingState holdingState, Point position, PointerType pointerType) : base(Gestures.HoldingEvent)
+ {
+ HoldingState = holdingState;
+ Position = position;
+ PointerType = pointerType;
+ }
+ }
+
+ public enum HoldingState
+ {
+ ///
+ /// A single contact has been detected and a time threshold is crossed without the contact being lifted, another contact detected, or another gesture started.
+ ///
+ Started,
+
+ ///
+ /// The single contact is lifted.
+ ///
+ Completed,
+
+ ///
+ /// An additional contact is detected or a subsequent gesture (such as a slide) is detected.
+ ///
+ Cancelled,
+ }
+}
diff --git a/src/Avalonia.Base/Input/InputElement.cs b/src/Avalonia.Base/Input/InputElement.cs
index fa755277cc..f233fdce51 100644
--- a/src/Avalonia.Base/Input/InputElement.cs
+++ b/src/Avalonia.Base/Input/InputElement.cs
@@ -188,11 +188,16 @@ namespace Avalonia.Input
///
public static readonly RoutedEvent TappedEvent = Gestures.TappedEvent;
+ ///
+ /// Defines the event.
+ ///
+ public static readonly RoutedEvent HoldingEvent = Gestures.HoldingEvent;
+
///
/// Defines the event.
///
public static readonly RoutedEvent DoubleTappedEvent = Gestures.DoubleTappedEvent;
-
+
private bool _isEffectivelyEnabled = true;
private bool _isFocused;
private bool _isKeyboardFocusWithin;
@@ -352,6 +357,15 @@ namespace Avalonia.Input
add { AddHandler(TappedEvent, value); }
remove { RemoveHandler(TappedEvent, value); }
}
+
+ ///
+ /// Occurs when a hold gesture occurs on the control.
+ ///
+ public event EventHandler? Holding
+ {
+ add { AddHandler(HoldingEvent, value); }
+ remove { RemoveHandler(HoldingEvent, value); }
+ }
///
/// Occurs when a double-tap gesture occurs on the control.
diff --git a/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs b/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
index dd3e1a4cb1..d0b27b057f 100644
--- a/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
+++ b/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
@@ -26,5 +26,7 @@ namespace Avalonia.Platform
};
}
public TimeSpan GetDoubleTapTime(PointerType type) => TimeSpan.FromMilliseconds(500);
+
+ public TimeSpan HoldWaitDuration { get; set; } = TimeSpan.FromMilliseconds(300);
}
}
diff --git a/src/Avalonia.Base/Platform/IPlatformSettings.cs b/src/Avalonia.Base/Platform/IPlatformSettings.cs
index e7921883fd..7c4c1420eb 100644
--- a/src/Avalonia.Base/Platform/IPlatformSettings.cs
+++ b/src/Avalonia.Base/Platform/IPlatformSettings.cs
@@ -27,5 +27,7 @@ namespace Avalonia.Platform
/// tap gesture.
///
TimeSpan GetDoubleTapTime(PointerType type);
+
+ TimeSpan HoldWaitDuration { get; set; }
}
}
diff --git a/src/Avalonia.Controls/Control.cs b/src/Avalonia.Controls/Control.cs
index 88c9823952..26db431a0e 100644
--- a/src/Avalonia.Controls/Control.cs
+++ b/src/Avalonia.Controls/Control.cs
@@ -366,16 +366,29 @@ namespace Avalonia.Controls
{
base.OnAttachedToVisualTreeCore(e);
+ AddHandler(Gestures.HoldingEvent, OnHoldEvent);
+
InitializeIfNeeded();
ScheduleOnLoadedCore();
}
+ private void OnHoldEvent(object? sender, HoldingRoutedEventArgs e)
+ {
+ if(e.HoldingState == HoldingState.Started)
+ {
+ // Trigger ContentRequest when hold has started
+ RaiseEvent(new ContextRequestedEventArgs());
+ }
+ }
+
///
protected sealed override void OnDetachedFromVisualTreeCore(VisualTreeAttachmentEventArgs e)
{
base.OnDetachedFromVisualTreeCore(e);
+ RemoveHandler(Gestures.HoldingEvent, OnHoldEvent);
+
OnUnloadedCore();
}
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index 93d16b5768..585a9cdf19 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -258,6 +258,8 @@ namespace Avalonia.Win32
public bool CurrentThreadIsLoopThread => _uiThread == Thread.CurrentThread;
+ public TimeSpan HoldWaitDuration { get; set; } = TimeSpan.FromMilliseconds(300);
+
public event Action Signaled;
public event EventHandler ShutdownRequested;
diff --git a/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs b/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs
index 59085a21ce..84ee35ba61 100644
--- a/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Input/GesturesTests.cs
@@ -1,9 +1,13 @@
+using System;
using System.Collections.Generic;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Input.GestureRecognizers;
using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Threading;
using Avalonia.UnitTests;
+using Moq;
using Xunit;
namespace Avalonia.Base.UnitTests.Input
@@ -169,6 +173,242 @@ namespace Avalonia.Base.UnitTests.Input
Assert.False(raised);
}
+ [Fact]
+ public void Hold_Should_Be_Raised_After_Hold_Duration()
+ {
+ using var scope = AvaloniaLocator.EnterScope();
+ var iSettingsMock = new Mock();
+ iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300));
+ iSettingsMock.Setup(x => x.GetTapSize(It.IsAny())).Returns(new Size(16, 16));
+ AvaloniaLocator.CurrentMutable.BindToSelf(this)
+ .Bind().ToConstant(iSettingsMock.Object);
+
+ var scheduledTimers = new List<(TimeSpan time, Action action)>();
+ using var app = UnitTestApplication.Start(new TestServices(
+ threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t))));
+
+ Border border = new Border();
+ Gestures.SetIsHoldWithMouseEnabled(border, true);
+ var decorator = new Decorator
+ {
+ Child = border
+ };
+ HoldingState holding = HoldingState.Cancelled;
+
+ decorator.AddHandler(Gestures.HoldingEvent, (s, e) => holding = e.HoldingState);
+
+ _mouse.Down(border);
+ Assert.False(holding != HoldingState.Cancelled);
+
+ // Verify timer duration, but execute it immediately.
+ var timer = Assert.Single(scheduledTimers);
+ Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time);
+ timer.action();
+
+ Assert.True(holding == HoldingState.Started);
+
+ _mouse.Up(border);
+
+ Assert.True(holding == HoldingState.Completed);
+ }
+
+ [Fact]
+ public void Hold_Should_Not_Raised_When_Pointer_Released_Before_Timer()
+ {
+ using var scope = AvaloniaLocator.EnterScope();
+ var iSettingsMock = new Mock();
+ iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300));
+ AvaloniaLocator.CurrentMutable.BindToSelf(this)
+ .Bind().ToConstant(iSettingsMock.Object);
+
+ var scheduledTimers = new List<(TimeSpan time, Action action)>();
+ using var app = UnitTestApplication.Start(new TestServices(
+ threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t))));
+
+ Border border = new Border();
+ Gestures.SetIsHoldWithMouseEnabled(border, true);
+ var decorator = new Decorator
+ {
+ Child = border
+ };
+ var raised = false;
+
+ decorator.AddHandler(Gestures.HoldingEvent, (s, e) => raised = e.HoldingState == HoldingState.Started);
+
+ _mouse.Down(border);
+ Assert.False(raised);
+
+ _mouse.Up(border);
+ Assert.False(raised);
+
+ // Verify timer duration, but execute it immediately.
+ var timer = Assert.Single(scheduledTimers);
+ Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time);
+ timer.action();
+
+ Assert.False(raised);
+ }
+
+ [Fact]
+ public void Hold_Should_Not_Raised_When_Pointer_Is_Moved_Before_Timer()
+ {
+ using var scope = AvaloniaLocator.EnterScope();
+ var iSettingsMock = new Mock();
+ iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300));
+ AvaloniaLocator.CurrentMutable.BindToSelf(this)
+ .Bind().ToConstant(iSettingsMock.Object);
+
+ var scheduledTimers = new List<(TimeSpan time, Action action)>();
+ using var app = UnitTestApplication.Start(new TestServices(
+ threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t))));
+
+ Border border = new Border();
+ Gestures.SetIsHoldWithMouseEnabled(border, true);
+ var decorator = new Decorator
+ {
+ Child = border
+ };
+ var raised = false;
+
+ decorator.AddHandler(Gestures.HoldingEvent, (s, e) => raised = e.HoldingState == HoldingState.Completed);
+
+ _mouse.Down(border);
+ Assert.False(raised);
+
+ _mouse.Move(border, position: new Point(20, 20));
+ Assert.False(raised);
+
+ // Verify timer duration, but execute it immediately.
+ var timer = Assert.Single(scheduledTimers);
+ Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time);
+ timer.action();
+
+ Assert.False(raised);
+ }
+
+ [Fact]
+ public void Hold_Should_Be_Cancelled_When_Second_Contact_Is_Detected()
+ {
+ using var scope = AvaloniaLocator.EnterScope();
+ var iSettingsMock = new Mock();
+ iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300));
+ AvaloniaLocator.CurrentMutable.BindToSelf(this)
+ .Bind().ToConstant(iSettingsMock.Object);
+
+ var scheduledTimers = new List<(TimeSpan time, Action action)>();
+ using var app = UnitTestApplication.Start(new TestServices(
+ threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t))));
+
+ Border border = new Border();
+ Gestures.SetIsHoldWithMouseEnabled(border, true);
+ var decorator = new Decorator
+ {
+ Child = border
+ };
+ var cancelled = false;
+
+ decorator.AddHandler(Gestures.HoldingEvent, (s, e) => cancelled = e.HoldingState == HoldingState.Cancelled);
+
+ _mouse.Down(border);
+ Assert.False(cancelled);
+
+ var timer = Assert.Single(scheduledTimers);
+ Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time);
+ timer.action();
+
+ var secondMouse = new MouseTestHelper();
+
+ secondMouse.Down(border);
+
+ Assert.True(cancelled);
+ }
+
+ [Fact]
+ public void Hold_Should_Be_Cancelled_When_Pointer_Moves_Too_Far()
+ {
+ using var scope = AvaloniaLocator.EnterScope();
+ var iSettingsMock = new Mock();
+ iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300));
+ iSettingsMock.Setup(x => x.GetTapSize(It.IsAny())).Returns(new Size(16, 16));
+ AvaloniaLocator.CurrentMutable.BindToSelf(this)
+ .Bind().ToConstant(iSettingsMock.Object);
+
+ var scheduledTimers = new List<(TimeSpan time, Action action)>();
+ using var app = UnitTestApplication.Start(new TestServices(
+ threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t))));
+
+ Border border = new Border();
+ Gestures.SetIsHoldWithMouseEnabled(border, true);
+ var decorator = new Decorator
+ {
+ Child = border
+ };
+ var cancelled = false;
+
+ decorator.AddHandler(Gestures.HoldingEvent, (s, e) => cancelled = e.HoldingState == HoldingState.Cancelled);
+
+ _mouse.Down(border);
+
+ var timer = Assert.Single(scheduledTimers);
+ Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time);
+ timer.action();
+
+ _mouse.Move(border, position: new Point(3, 3));
+
+ Assert.False(cancelled);
+
+ _mouse.Move(border, position: new Point(20, 20));
+
+ Assert.True(cancelled);
+ }
+
+ [Fact]
+ public void Hold_Should_Not_Be_Raised_For_Multiple_Contacts()
+ {
+ using var scope = AvaloniaLocator.EnterScope();
+ var iSettingsMock = new Mock();
+ iSettingsMock.Setup(x => x.HoldWaitDuration).Returns(TimeSpan.FromMilliseconds(300));
+ AvaloniaLocator.CurrentMutable.BindToSelf(this)
+ .Bind().ToConstant(iSettingsMock.Object);
+
+ var scheduledTimers = new List<(TimeSpan time, Action action)>();
+ using var app = UnitTestApplication.Start(new TestServices(
+ threadingInterface: CreatePlatformThreadingInterface(t => scheduledTimers.Add(t))));
+
+ Border border = new Border();
+ Gestures.SetIsHoldWithMouseEnabled(border, true);
+ var decorator = new Decorator
+ {
+ Child = border
+ };
+ var raised = false;
+
+ decorator.AddHandler(Gestures.HoldingEvent, (s, e) => raised = e.HoldingState == HoldingState.Completed);
+
+ var secondMouse = new MouseTestHelper();
+
+ _mouse.Down(border, MouseButton.Left);
+
+ // Verify timer duration, but execute it immediately.
+ var timer = Assert.Single(scheduledTimers);
+ Assert.Equal(iSettingsMock.Object.HoldWaitDuration, timer.time);
+ timer.action();
+
+ secondMouse.Down(border, MouseButton.Left);
+
+ Assert.False(raised);
+ }
+
+ private static IPlatformThreadingInterface CreatePlatformThreadingInterface(Action<(TimeSpan, Action)> callback)
+ {
+ var threadingInterface = new Mock();
+ threadingInterface.SetupGet(p => p.CurrentThreadIsLoopThread).Returns(true);
+ threadingInterface.Setup(p => p
+ .StartTimer(It.IsAny(), It.IsAny(), It.IsAny()))
+ .Callback((_, t, a) => callback((t, a)));
+ return threadingInterface.Object;
+ }
+
private static void AddHandlers(
Decorator decorator,
Border border,
diff --git a/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs b/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs
index c0c0182622..36587ea222 100644
--- a/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Input/TouchDeviceTests.cs
@@ -207,7 +207,7 @@ namespace Avalonia.Input.UnitTests
private IDisposable UnitTestApp(TimeSpan doubleClickTime = new TimeSpan())
{
var unitTestApp = UnitTestApplication.Start(
- new TestServices(inputManager: new InputManager()));
+ new TestServices(inputManager: new InputManager(), threadingInterface: Mock.Of(x => x.CurrentThreadIsLoopThread == true)));
var iSettingsMock = new Mock();
iSettingsMock.Setup(x => x.GetDoubleTapTime(It.IsAny())).Returns(doubleClickTime);
iSettingsMock.Setup(x => x.GetDoubleTapSize(It.IsAny())).Returns(new Size(16, 16));