[OSX] Add PointerMagnifyGesture, PointerRotateGesture, PointerSwipeGesture events

src/Avalonia.Input/InputElement.cs

@@ -186,6 +186,30 @@ namespace Avalonia.Input
             RoutedEvent.Register<InputElement, PointerWheelEventArgs>(
                 "PointerWheelChanged",
                 RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
+        
+        /// <summary>
+        /// Defines the <see cref="PointerMagnifyGesture"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<PointerMagnifyGestureEventArgs> PointerMagnifyGestureEvent =
+            RoutedEvent.Register<InputElement, PointerMagnifyGestureEventArgs>(
+                "PointerMagnifyGesture",
+                RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
+        
+        /// <summary>
+        /// Defines the <see cref="PointerRotateGesture"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<PointerRotateGestureEventArgs> PointerRotateGestureEvent =
+            RoutedEvent.Register<InputElement, PointerRotateGestureEventArgs>(
+                "PointerRotateGesture",
+                RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
+        
+        /// <summary>
+        /// Defines the <see cref="PointerSwipeGesture"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<PointerSwipeGestureEventArgs> PointerSwipeGestureEvent =
+            RoutedEvent.Register<InputElement, PointerSwipeGestureEventArgs>(
+                "PointerSwipeGesture",
+                RoutingStrategies.Tunnel | RoutingStrategies.Bubble);
 
         /// <summary>
         /// Defines the <see cref="Tapped"/> event.
@@ -223,6 +247,9 @@ namespace Avalonia.Input
             PointerReleasedEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerReleased(e));
             PointerCaptureLostEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerCaptureLost(e));
             PointerWheelChangedEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerWheelChanged(e));
+            PointerMagnifyGestureEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerMagnifyGesture(e));
+            PointerRotateGestureEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerRotateGesture(e));
+            PointerSwipeGestureEvent.AddClassHandler<InputElement>((x, e) => x.OnPointerSwipeGesture(e));
         }
 
         public InputElement()
@@ -349,13 +376,43 @@ namespace Avalonia.Input
         }
         
         /// <summary>
-        /// Occurs when the mouse wheen is scrolled over the control.
+        /// Occurs when the mouse is scrolled over the control.
         /// </summary>
         public event EventHandler<PointerWheelEventArgs> PointerWheelChanged
         {
             add { AddHandler(PointerWheelChangedEvent, value); }
             remove { RemoveHandler(PointerWheelChangedEvent, value); }
         }
+        
+        /// <summary>
+        /// Occurs when the user uses magnify (Pitch to Zoom) gesture on a trackpad and pointer is over the control.
+        /// Works only on macOS.
+        /// </summary>
+        public event EventHandler<PointerMagnifyGestureEventArgs> PointerMagnifyGesture
+        {
+            add { AddHandler(PointerMagnifyGestureEvent, value); }
+            remove { RemoveHandler(PointerMagnifyGestureEvent, value); }
+        }
+        
+        /// <summary>
+        /// Occurs when the user uses rotate gesture on a trackpad and pointer is over the control.
+        /// Works only on macOS.
+        /// </summary>
+        public event EventHandler<PointerRotateGestureEventArgs> PointerRotateGesture
+        {
+            add { AddHandler(PointerRotateGestureEvent, value); }
+            remove { RemoveHandler(PointerRotateGestureEvent, value); }
+        }
+        
+        /// <summary>
+        /// Occurs when the user uses swipe gesture on a trackpad and pointer is over the control.
+        /// Works only on macOS.
+        /// </summary>
+        public event EventHandler<PointerSwipeGestureEventArgs> PointerSwipeGesture
+        {
+            add { AddHandler(PointerSwipeGestureEvent, value); }
+            remove { RemoveHandler(PointerSwipeGestureEvent, value); }
+        }
 
         /// <summary>
         /// Occurs when a tap gesture occurs on the control.
@@ -617,6 +674,30 @@ namespace Avalonia.Input
         protected virtual void OnPointerWheelChanged(PointerWheelEventArgs e)
         {
         }
+        
+        /// <summary>
+        /// Called before the <see cref="PointerMagnifyGesture"/> trackpad event occurs.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        protected virtual void OnPointerMagnifyGesture(PointerMagnifyGestureEventArgs e)
+        {
+        }
+        
+        /// <summary>
+        /// Called before the <see cref="PointerRotateGesture"/> trackpad event occurs.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        protected virtual void OnPointerRotateGesture(PointerRotateGestureEventArgs e)
+        {
+        }
+        
+        /// <summary>
+        /// Called before the <see cref="PointerSwipeGesture"/> trackpad event occurs.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        protected virtual void OnPointerSwipeGesture(PointerSwipeGestureEventArgs e)
+        {
+        }
 
         protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
         {

src/Avalonia.Input/MouseDevice.cs

@@ -178,6 +178,15 @@ namespace Avalonia.Input
                 case RawPointerEventType.Wheel:
                     e.Handled = MouseWheel(mouse, e.Timestamp, e.Root, e.Position, props, ((RawMouseWheelEventArgs)e).Delta, keyModifiers);
                     break;
+                case RawPointerEventType.Magnify:
+                    e.Handled = GestureMagnify(mouse, e.Timestamp, e.Root, e.Position, props, ((RawPointerGestureEventArgs)e).Delta, keyModifiers);
+                    break;
+                case RawPointerEventType.Rotate:
+                    e.Handled = GestureRotate(mouse, e.Timestamp, e.Root, e.Position, props, ((RawPointerGestureEventArgs)e).Delta, keyModifiers);
+                    break;
+                case RawPointerEventType.Swipe:
+                    e.Handled = GestureSwipe(mouse, e.Timestamp, e.Root, e.Position, props, ((RawPointerGestureEventArgs)e).Delta, keyModifiers);
+                    break;
             }
         }
 
@@ -331,6 +340,69 @@ namespace Avalonia.Input
 
             return false;
         }
+        
+        private bool GestureMagnify(IMouseDevice device, ulong timestamp, IInputRoot root, Point p,
+            PointerPointProperties props,
+            Vector delta, KeyModifiers inputModifiers)
+        {
+            device = device ?? throw new ArgumentNullException(nameof(device));
+            root = root ?? throw new ArgumentNullException(nameof(root));
+
+            var hit = HitTest(root, p);
+
+            if (hit != null)
+            {
+                var source = GetSource(hit);
+                var e = new PointerMagnifyGestureEventArgs(source, _pointer, root, p, timestamp, props, inputModifiers, delta.X);
+
+                source?.RaiseEvent(e);
+                return e.Handled;
+            }
+
+            return false;
+        }
+        
+        private bool GestureRotate(IMouseDevice device, ulong timestamp, IInputRoot root, Point p,
+            PointerPointProperties props,
+            Vector delta, KeyModifiers inputModifiers)
+        {
+            device = device ?? throw new ArgumentNullException(nameof(device));
+            root = root ?? throw new ArgumentNullException(nameof(root));
+
+            var hit = HitTest(root, p);
+
+            if (hit != null)
+            {
+                var source = GetSource(hit);
+                var e = new PointerRotateGestureEventArgs(source, _pointer, root, p, timestamp, props, inputModifiers, delta.X);
+
+                source?.RaiseEvent(e);
+                return e.Handled;
+            }
+
+            return false;
+        }
+        
+        private bool GestureSwipe(IMouseDevice device, ulong timestamp, IInputRoot root, Point p,
+            PointerPointProperties props,
+            Vector delta, KeyModifiers inputModifiers)
+        {
+            device = device ?? throw new ArgumentNullException(nameof(device));
+            root = root ?? throw new ArgumentNullException(nameof(root));
+
+            var hit = HitTest(root, p);
+
+            if (hit != null)
+            {
+                var source = GetSource(hit);
+                var e = new PointerSwipeGestureEventArgs(source, _pointer, root, p, timestamp, props, inputModifiers, delta);
+
+                source?.RaiseEvent(e);
+                return e.Handled;
+            }
+
+            return false;
+        }
 
         private IInteractive GetSource(IVisual hit)
         {

src/Avalonia.Input/PointerMagnifyGestureEventArgs.cs

@@ -0,0 +1,19 @@
+using Avalonia.Interactivity;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Input
+{
+    public class PointerMagnifyGestureEventArgs : PointerEventArgs
+    {
+        public double Delta { get; set; }
+
+        public PointerMagnifyGestureEventArgs(IInteractive source, IPointer pointer, IVisual rootVisual,
+            Point rootVisualPosition, ulong timestamp,
+            PointerPointProperties properties, KeyModifiers modifiers, double delta) 
+            : base(InputElement.PointerMagnifyGestureEvent, source, pointer, rootVisual, rootVisualPosition,
+                timestamp, properties, modifiers)
+        {
+            Delta = delta;
+        }
+    }
+}

src/Avalonia.Input/PointerRotateGestureEventArgs.cs

@@ -0,0 +1,19 @@
+using Avalonia.Interactivity;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Input
+{
+    public class PointerRotateGestureEventArgs : PointerEventArgs
+    {
+        public double Delta { get; set; }
+
+        public PointerRotateGestureEventArgs(IInteractive source, IPointer pointer, IVisual rootVisual,
+            Point rootVisualPosition, ulong timestamp,
+            PointerPointProperties properties, KeyModifiers modifiers, double delta) 
+            : base(InputElement.PointerRotateGestureEvent, source, pointer, rootVisual, rootVisualPosition,
+                timestamp, properties, modifiers)
+        {
+            Delta = delta;
+        }
+    }
+}

src/Avalonia.Input/PointerSwipeGestureEventArgs.cs

@@ -0,0 +1,19 @@
+using Avalonia.Interactivity;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Input
+{
+    public class PointerSwipeGestureEventArgs : PointerEventArgs
+    {
+        public Vector Delta { get; set; }
+
+        public PointerSwipeGestureEventArgs(IInteractive source, IPointer pointer, IVisual rootVisual,
+            Point rootVisualPosition, ulong timestamp,
+            PointerPointProperties properties, KeyModifiers modifiers, Vector delta) 
+            : base(InputElement.PointerSwipeGestureEvent, source, pointer, rootVisual, rootVisualPosition,
+                timestamp, properties, modifiers)
+        {
+            Delta = delta;
+        }
+    }
+}

src/Avalonia.Input/Raw/RawPointerEventArgs.cs

@@ -21,7 +21,10 @@ namespace Avalonia.Input.Raw
         TouchBegin,
         TouchUpdate,
         TouchEnd,
-        TouchCancel
+        TouchCancel,
+        Magnify,
+        Rotate,
+        Swipe
     }
 
     /// <summary>

src/Avalonia.Input/Raw/RawPointerGestureEventArgs.cs

@@ -0,0 +1,19 @@
+namespace Avalonia.Input.Raw
+{
+    public class RawPointerGestureEventArgs : RawPointerEventArgs
+    {
+        public RawPointerGestureEventArgs(
+            IInputDevice device,
+            ulong timestamp,
+            IInputRoot root,
+            RawPointerEventType gestureType,
+            Point position,
+            Vector delta, RawInputModifiers inputModifiers)
+            : base(device, timestamp, root, gestureType, position, inputModifiers)
+        {
+            Delta = delta;
+        }
+
+        public Vector Delta { get; private set; }
+    }
+}

src/Avalonia.Native/WindowImplBase.cs

@@ -306,11 +306,28 @@ namespace Avalonia.Native
             switch (type)
             {
                 case AvnRawMouseEventType.Wheel:
-                    Input?.Invoke(new RawMouseWheelEventArgs(_mouse, timeStamp, _inputRoot, point.ToAvaloniaPoint(), new Vector(delta.X, delta.Y), (RawInputModifiers)modifiers));
+                    Input?.Invoke(new RawMouseWheelEventArgs(_mouse, timeStamp, _inputRoot,
+                        point.ToAvaloniaPoint(), new Vector(delta.X, delta.Y), (RawInputModifiers)modifiers));
+                    break;
+                
+                case AvnRawMouseEventType.Magnify:
+                    Input?.Invoke(new RawPointerGestureEventArgs(_mouse, timeStamp, _inputRoot, RawPointerEventType.Magnify, 
+                        point.ToAvaloniaPoint(), new Vector(delta.X, delta.Y), (RawInputModifiers)modifiers));
+                    break;
+                    
+                case AvnRawMouseEventType.Rotate:
+                    Input?.Invoke(new RawPointerGestureEventArgs(_mouse, timeStamp, _inputRoot, RawPointerEventType.Rotate, 
+                        point.ToAvaloniaPoint(), new Vector(delta.X, delta.Y), (RawInputModifiers)modifiers));
+                    break;
+                
+                case AvnRawMouseEventType.Swipe:
+                    Input?.Invoke(new RawPointerGestureEventArgs(_mouse, timeStamp, _inputRoot, RawPointerEventType.Swipe,
+                        point.ToAvaloniaPoint(), new Vector(delta.X, delta.Y), (RawInputModifiers)modifiers));
                     break;
 
                 default:
-                    var e = new RawPointerEventArgs(_mouse, timeStamp, _inputRoot, (RawPointerEventType)type, point.ToAvaloniaPoint(), (RawInputModifiers)modifiers);
+                    var e = new RawPointerEventArgs(_mouse, timeStamp, _inputRoot, (RawPointerEventType)type,
+                        point.ToAvaloniaPoint(), (RawInputModifiers)modifiers);
                     
                     if(!ChromeHitTest(e))
                     {