Implement PointerGestureRecognizer

src/Controls/samples/Controls.Sample/Pages/Core/PointerGestureGalleryPage.xaml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<views:BasePage 
+ xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+ xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+ x:Class="Maui.Controls.Sample.Pages.PointerGestureGalleryPage"
+ xmlns:views="clr-namespace:Maui.Controls.Sample.Pages.Base">
+ <StackLayout>
+ <Label 
+ x:Name="hoverLabel"
+ FontSize="24"
+ Text="Hover me!">
+ <Label.GestureRecognizers>
+ <PointerGestureRecognizer PointerEntered="HoverBegan" PointerExited="HoverEnded" PointerMoved="HoverMoved" />
+ </Label.GestureRecognizers>
+ </Label>
+ <Label x:Name="positionLabel" Text="Hover above label to reveal pointer position"/>
+ </StackLayout>
+</views:BasePage>

src/Controls/samples/Controls.Sample/Pages/Core/PointerGestureGalleryPage.xaml.cs

@@ -0,0 +1,28 @@
+using Microsoft.Maui.Controls;
+
+namespace Maui.Controls.Sample.Pages
+{
+ public partial class PointerGestureGalleryPage
+ {
+ public PointerGestureGalleryPage()
+ {
+ InitializeComponent();
+ }
+
+ private void HoverBegan(object sender, PointerEventArgs e)
+ {
+ hoverLabel.Text = "Thanks for hovering me!";
+ }
+
+ private void HoverEnded(object sender, PointerEventArgs e)
+ {
+ hoverLabel.Text = "Hover me again!";
+ positionLabel.Text = "Hover above label to reveal pointer position again";
+ }
+
+ private void HoverMoved(object sender, PointerEventArgs e)
+ {
+ positionLabel.Text = $"Pointer position is at: {e.GetPosition((View)sender)}";
+ }
+ }
+}

src/Controls/samples/Controls.Sample/ViewModels/CoreViewModel.cs

@@ -49,7 +49,7 @@ protected override IEnumerable<SectionModel> CreateItems() => new[]
  "Focus and onfocus views, detect when a view gains focus and more."),
 
  new SectionModel(typeof(GesturesPage), "Gestures",
- "Use tap, pinch, pan, swipe, and drag and drop gestures on View instances."),
+ "Use tap, pinch, pan, swipe, drag and drop, and pointer gestures on View instances."),
 
  new SectionModel(typeof(InputTransparentPage), "InputTransparent",
  "Manage whether a view participates in the user interaction cycle."),

src/Controls/samples/Controls.Sample/ViewModels/GesturesViewModel.cs

@@ -19,6 +19,8 @@ protected override IEnumerable<SectionModel> CreateItems() => new[]
  "Swipe Gesture."),
  new SectionModel(typeof(TapGestureGalleryPage), "Tap Gesture",
  "Tap Gesture."),
+ new SectionModel(typeof(PointerGestureGalleryPage), "Pointer Gesture",
+ "Pointer Gesture."),
  };
  }
 }

src/Controls/src/Core/Platform/GestureManager/GestureManager.Android.cs

@@ -172,20 +172,6 @@ void SetupGestures()
  {
  platformView.Touch += OnPlatformViewTouched;
  }
-
- if (View is not Microsoft.Maui.IButton)
- {
- platformView.KeyPress += PlatformView_KeyPress;
- platformView.Click += PlatformView_Click;
- }
- }
-
- private void PlatformView_Click(object? sender, EventArgs e)
- {
- }
-
- private void PlatformView_KeyPress(object? sender, AView.KeyEventArgs e)
- {
  }
 
  void OnPlatformViewTouched(object? sender, AView.TouchEventArgs e)

src/Controls/src/Core/Platform/GestureManager/GestureManager.Windows.cs

@@ -8,6 +8,7 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Maui.Controls.Internals;
 using Microsoft.Maui.Graphics;
+using Microsoft.UI.Input;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Input;
 using Microsoft.UI.Xaml.Media.Imaging;
@@ -318,6 +319,9 @@ void ClearContainerEventHandlers()
  _container.PointerExited -= OnPointerExited;
  _container.PointerReleased -= OnPointerReleased;
  _container.PointerCanceled -= OnPointerCanceled;
+ _container.PointerEntered -= OnPgrPointerEntered;
+ _container.PointerExited -= OnPgrPointerExited;
+ _container.PointerMoved -= OnPgrPointerMoved;
  }
  }
 
@@ -481,12 +485,46 @@ void OnPointerReleased(object sender, PointerRoutedEventArgs e)
  PanComplete(true);
  }
 
+ void OnPgrPointerEntered(object sender, PointerRoutedEventArgs e) 
+ => HandlePgrPointerEvent(e, (view, recognizer) 
+ => recognizer.SendPointerEntered(view, (relativeTo) => GetPosition(relativeTo, e)));
+
+ void OnPgrPointerExited(object sender, PointerRoutedEventArgs e)
+ => HandlePgrPointerEvent(e, (view, recognizer) 
+ => recognizer.SendPointerExited(view, (relativeTo) => GetPosition(relativeTo, e)));
+
+ void OnPgrPointerMoved(object sender, PointerRoutedEventArgs e)
+ => HandlePgrPointerEvent(e, (view, recognizer) 
+ => recognizer.SendPointerMoved(view, (relativeTo) => GetPosition(relativeTo, e)));
+
+ private void HandlePgrPointerEvent(PointerRoutedEventArgs e, Action<View, PointerGestureRecognizer> SendPointerEvent)
+ {
+ var view = Element as View;
+ if (view == null)
+ return;
+
+ var pointerGestures = view.GestureRecognizers.GetGesturesFor<PointerGestureRecognizer>();
+ foreach (var recognizer in pointerGestures)
+ {
+ SendPointerEvent.Invoke(view, recognizer);
+ }
+ }
+
+ Point? GetPosition(IElement? relativeTo, RoutedEventArgs e)
+ {
+ var result = e.GetPositionRelativeToElement(relativeTo);
+ if (result == null)
+ return null;
+
+ return new Point(result.Value.X, result.Value.Y);
+ }
+
  void OnTap(object sender, RoutedEventArgs e)
  {
  var view = Element as View;
  if (view == null)
  return;
- 
+
  var tapPosition = e.GetPositionRelativeToPlatformElement(Control);
 
  if (tapPosition == null)
@@ -510,14 +548,7 @@ bool ProcessGestureRecognizers(IEnumerable<TapGestureRecognizer>? tapGestures)
 
  foreach (var recognizer in tapGestures)
  {
- recognizer.SendTapped(view, (relativeTo) =>
- {
- var result = e.GetPositionRelativeToElement(relativeTo);
- if (result == null)
- return null;
-
- return new Point(result.Value.X, result.Value.Y);
- });
+ recognizer.SendTapped(view, (relativeTo) => GetPosition(relativeTo, e));
 
  e.SetHandled(true);
  handled = true;
@@ -545,6 +576,7 @@ bool ValidateGesture(TapGestureRecognizer g)
  }
  }
 
+
  void SwipeComplete(bool success)
  {
  var view = Element as View;
@@ -679,6 +711,10 @@ void UpdatingGestureRecognizers()
  }
  }
 
+ _container.PointerEntered += OnPgrPointerEntered;
+ _container.PointerExited += OnPgrPointerExited;
+ _container.PointerMoved += OnPgrPointerMoved;
+
  bool hasSwipeGesture = gestures.GetGesturesFor<SwipeGestureRecognizer>().GetEnumerator().MoveNext();
  bool hasPinchGesture = gestures.GetGesturesFor<PinchGestureRecognizer>().GetEnumerator().MoveNext();
  bool hasPanGesture = gestures.GetGesturesFor<PanGestureRecognizer>().GetEnumerator().MoveNext();

src/Controls/src/Core/PointerEventArgs.cs

@@ -0,0 +1,28 @@
+#nullable enable
+
+using Microsoft.Maui.Graphics;
+using System;
+
+namespace Microsoft.Maui.Controls
+{
+ /// <summary>
+ /// Arguments for PointerGestureRecognizer events.
+ /// </summary>
+ public class PointerEventArgs : EventArgs
+ {
+
+ Func<IElement?, Point?>? _getPosition;
+
+ public PointerEventArgs()
+ {
+ }
+
+ internal PointerEventArgs(Func<IElement?, Point?>? getPosition)
+ {
+ _getPosition = getPosition;
+ }
+
+ public virtual Point? GetPosition(Element? relativeTo) =>
+ _getPosition?.Invoke(relativeTo);
+ }
+}

src/Controls/src/Core/PointerGestureRecognizer.cs

@@ -0,0 +1,101 @@
+#nullable enable
+using System;
+using System.ComponentModel;
+using Microsoft.Maui.Graphics;
+using System.Windows.Input;
+
+namespace Microsoft.Maui.Controls
+{
+ /// <summary>
+ /// Provides pointer gesture recognition and events.
+ /// </summary>
+ public sealed class PointerGestureRecognizer : GestureRecognizer
+ {
+ public static readonly BindableProperty PointerEnteredCommandProperty = BindableProperty.Create(nameof(PointerEnteredCommand), typeof(ICommand), typeof(PointerGestureRecognizer), null);
+
+ public static readonly BindableProperty PointerEnteredCommandParameterProperty = BindableProperty.Create(nameof(PointerEnteredCommandParameter), typeof(object), typeof(PointerGestureRecognizer), null);
+
+ public static readonly BindableProperty PointerExitedCommandProperty = BindableProperty.Create(nameof(PointerExitedCommand), typeof(ICommand), typeof(PointerGestureRecognizer), null);
+
+ public static readonly BindableProperty PointerExitedCommandParameterProperty = BindableProperty.Create(nameof(PointerExitedCommandParameter), typeof(object), typeof(PointerGestureRecognizer), null);
+
+ public static readonly BindableProperty PointerMovedCommandProperty = BindableProperty.Create(nameof(PointerMovedCommand), typeof(ICommand), typeof(PointerGestureRecognizer), null);
+
+ public static readonly BindableProperty PointerMovedCommandParameterProperty = BindableProperty.Create(nameof(PointerMovedCommandParameter), typeof(object), typeof(PointerGestureRecognizer), null);
+
+ public PointerGestureRecognizer()
+ {
+ }
+
+ public event EventHandler<PointerEventArgs>? PointerEntered;
+ public event EventHandler<PointerEventArgs>? PointerExited;
+ public event EventHandler<PointerEventArgs>? PointerMoved;
+
+ public ICommand PointerEnteredCommand
+ {
+ get { return (ICommand)GetValue(PointerEnteredCommandProperty); }
+ set { SetValue(PointerEnteredCommandProperty, value); }
+ }
+
+ public ICommand PointerEnteredCommandParameter
+ {
+ get { return (ICommand)GetValue(PointerEnteredCommandParameterProperty); }
+ set { SetValue(PointerEnteredCommandParameterProperty, value); }
+ }
+ public ICommand PointerExitedCommand
+ {
+ get { return (ICommand)GetValue(PointerExitedCommandProperty); }
+ set { SetValue(PointerExitedCommandProperty, value); }
+ }
+ public ICommand PointerExitedCommandParameter
+ {
+ get { return (ICommand)GetValue(PointerExitedCommandParameterProperty); }
+ set { SetValue(PointerExitedCommandParameterProperty, value); }
+ }
+
+ public ICommand PointerMovedCommand
+ {
+ get { return (ICommand)GetValue(PointerMovedCommandProperty); }
+ set { SetValue(PointerMovedCommandProperty, value); }
+ }
+
+ public ICommand PointerMovedCommandParameter
+ {
+ get { return (ICommand)GetValue(PointerMovedCommandParameterProperty); }
+ set { SetValue(PointerMovedCommandParameterProperty, value); }
+ }
+
+ internal void SendPointerEntered(View sender, Func<IElement?, Point?>? getPosition)
+ {
+ ICommand cmd = PointerEnteredCommand;
+ if (cmd != null && cmd.CanExecute(PointerEnteredCommandParameter))
+ cmd.Execute(PointerEnteredCommandParameter);
+
+ EventHandler<PointerEventArgs>? handler = PointerEntered;
+ if (handler != null)
+ handler?.Invoke(sender, new PointerEventArgs(getPosition));
+ }
+
+ internal void SendPointerExited(View sender, Func<IElement?, Point?>? getPosition)
+ {
+ ICommand cmd = PointerExitedCommand;
+ if (cmd != null && cmd.CanExecute(PointerExitedCommandParameter))
+ cmd.Execute(PointerExitedCommandParameter);
+
+ EventHandler<PointerEventArgs>? handler = PointerExited;
+ if (handler != null)
+ handler?.Invoke(sender, new PointerEventArgs(getPosition));
+ }
+
+ internal void SendPointerMoved(View sender, Func<IElement?, Point?>? getPosition)
+ {
+ ICommand cmd = PointerMovedCommand;
+ if (cmd != null && cmd.CanExecute(PointerMovedCommandParameter))
+ cmd.Execute(PointerMovedCommandParameter);
+
+ EventHandler<PointerEventArgs>? handler = PointerMoved;
+ if (handler != null)
+ handler?.Invoke(sender, new PointerEventArgs(getPosition));
+ }
+ }
+}

src/Core/src/Platform/Windows/RoutedEventArgsExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using Microsoft.Maui.Graphics;
 using Microsoft.UI.Xaml.Input;
 using Microsoft.UI.Xaml;
 using WPoint = Windows.Foundation.Point;
@@ -37,6 +38,11 @@ public static void SetHandled(this RoutedEventArgs e, bool value)
  return t.GetPosition(relativeTo);
  else if (e is DoubleTappedRoutedEventArgs dt)
  return dt.GetPosition(relativeTo);
+ else if (e is PointerRoutedEventArgs p)
+ {
+ var point = p.GetCurrentPoint(relativeTo);
+ return new WPoint(point.Position.X, point.Position.Y);
+ }
 
  return null;
  }