PR comments

src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs

@@ -373,9 +373,9 @@ namespace Avalonia.Controls.Platform
 
         protected internal virtual void RawInput(RawInputEventArgs e)
         {
-            var mouse = e as RawMouseEventArgs;
+            var mouse = e as RawPointerEventArgs;
 
-            if (mouse?.Type == RawMouseEventType.NonClientLeftButtonDown)
+            if (mouse?.Type == RawPointerEventType.NonClientLeftButtonDown)
             {
                 Menu.Close();
             }

src/Avalonia.Controls/Platform/InProcessDragSource.cs

@@ -43,7 +43,7 @@ namespace Avalonia.Platform
                 _lastPosition = default(Point);
                 _allowedEffects = allowedEffects;
 
-                using (_inputManager.PreProcess.OfType<RawMouseEventArgs>().Subscribe(ProcessMouseEvents))
+                using (_inputManager.PreProcess.OfType<RawPointerEventArgs>().Subscribe(ProcessMouseEvents))
                 {
                     using (_inputManager.PreProcess.OfType<RawKeyEventArgs>().Subscribe(ProcessKeyEvents))
                     {
@@ -153,7 +153,7 @@ namespace Avalonia.Platform
             }
         }
 
-        private void ProcessMouseEvents(RawMouseEventArgs e)
+        private void ProcessMouseEvents(RawPointerEventArgs e)
         {
             if (!_initialInputModifiers.HasValue)
                 _initialInputModifiers = e.InputModifiers & MOUSE_INPUTMODIFIERS;
@@ -174,22 +174,22 @@ namespace Avalonia.Platform
             
             switch (e.Type)
             {
-                case RawMouseEventType.LeftButtonDown:
-                case RawMouseEventType.RightButtonDown:
-                case RawMouseEventType.MiddleButtonDown:
-                case RawMouseEventType.NonClientLeftButtonDown:
+                case RawPointerEventType.LeftButtonDown:
+                case RawPointerEventType.RightButtonDown:
+                case RawPointerEventType.MiddleButtonDown:
+                case RawPointerEventType.NonClientLeftButtonDown:
                     CancelDragging();
                     e.Handled = true;
                     return;
-                case RawMouseEventType.LeaveWindow:
+                case RawPointerEventType.LeaveWindow:
                     RaiseEventAndUpdateCursor(RawDragEventType.DragLeave, e.Root, e.Position,  e.InputModifiers); break;
-                case RawMouseEventType.LeftButtonUp:
+                case RawPointerEventType.LeftButtonUp:
                     CheckDraggingAccepted(InputModifiers.LeftMouseButton); break;
-                case RawMouseEventType.MiddleButtonUp:
+                case RawPointerEventType.MiddleButtonUp:
                     CheckDraggingAccepted(InputModifiers.MiddleMouseButton); break;
-                case RawMouseEventType.RightButtonUp:
+                case RawPointerEventType.RightButtonUp:
                     CheckDraggingAccepted(InputModifiers.RightMouseButton); break;
-                case RawMouseEventType.Move:
+                case RawPointerEventType.Move:
                     var mods = e.InputModifiers & MOUSE_INPUTMODIFIERS;
                     if (_initialInputModifiers.Value != mods)
                     {

src/Avalonia.Controls/Primitives/Popup.cs

@@ -421,9 +421,9 @@ namespace Avalonia.Controls.Primitives
 
         private void ListenForNonClientClick(RawInputEventArgs e)
         {
-            var mouse = e as RawMouseEventArgs;
+            var mouse = e as RawPointerEventArgs;
 
-            if (!StaysOpen && mouse?.Type == RawMouseEventType.NonClientLeftButtonDown)
+            if (!StaysOpen && mouse?.Type == RawPointerEventType.NonClientLeftButtonDown)
             {
                 Close();
             }

src/Avalonia.Controls/Remote/Server/RemoteServerTopLevelImpl.cs

@@ -39,21 +39,21 @@ namespace Avalonia.Controls.Remote.Server
             KeyboardDevice = AvaloniaLocator.Current.GetService<IKeyboardDevice>();
         }
 
-        private static RawMouseEventType GetAvaloniaEventType (Avalonia.Remote.Protocol.Input.MouseButton button, bool pressed)
+        private static RawPointerEventType GetAvaloniaEventType (Avalonia.Remote.Protocol.Input.MouseButton button, bool pressed)
         {
             switch (button)
             {
                 case Avalonia.Remote.Protocol.Input.MouseButton.Left:
-                    return pressed ? RawMouseEventType.LeftButtonDown : RawMouseEventType.LeftButtonUp;
+                    return pressed ? RawPointerEventType.LeftButtonDown : RawPointerEventType.LeftButtonUp;
 
                 case Avalonia.Remote.Protocol.Input.MouseButton.Middle:
-                    return pressed ? RawMouseEventType.MiddleButtonDown : RawMouseEventType.MiddleButtonUp;
+                    return pressed ? RawPointerEventType.MiddleButtonDown : RawPointerEventType.MiddleButtonUp;
 
                 case Avalonia.Remote.Protocol.Input.MouseButton.Right:
-                    return pressed ? RawMouseEventType.RightButtonDown : RawMouseEventType.RightButtonUp;
+                    return pressed ? RawPointerEventType.RightButtonDown : RawPointerEventType.RightButtonUp;
 
                 default:
-                    return RawMouseEventType.Move;
+                    return RawPointerEventType.Move;
             }
         }
 
@@ -166,11 +166,11 @@ namespace Avalonia.Controls.Remote.Server
                 {
                     Dispatcher.UIThread.Post(() =>
                     {
-                        Input?.Invoke(new RawMouseEventArgs(
+                        Input?.Invoke(new RawPointerEventArgs(
                             MouseDevice, 
                             0, 
                             InputRoot, 
-                            RawMouseEventType.Move, 
+                            RawPointerEventType.Move, 
                             new Point(pointer.X, pointer.Y), 
                             GetAvaloniaInputModifiers(pointer.Modifiers)));
                     }, DispatcherPriority.Input);
@@ -179,7 +179,7 @@ namespace Avalonia.Controls.Remote.Server
                 {
                     Dispatcher.UIThread.Post(() =>
                     {
-                        Input?.Invoke(new RawMouseEventArgs(
+                        Input?.Invoke(new RawPointerEventArgs(
                             MouseDevice,
                             0,
                             InputRoot,
@@ -192,7 +192,7 @@ namespace Avalonia.Controls.Remote.Server
                 {
                     Dispatcher.UIThread.Post(() =>
                     {
-                        Input?.Invoke(new RawMouseEventArgs(
+                        Input?.Invoke(new RawPointerEventArgs(
                             MouseDevice,
                             0,
                             InputRoot,

src/Avalonia.Input/IMouseDevice.cs

@@ -1,6 +1,8 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System;
+
 namespace Avalonia.Input
 {
     /// <summary>
@@ -11,6 +13,7 @@ namespace Avalonia.Input
         /// <summary>
         /// Gets the mouse position, in screen coordinates.
         /// </summary>
+        [Obsolete("Use PointerEventArgs.GetPosition")]
         PixelPoint Position { get; }
 
         void SceneInvalidated(IInputRoot root, Rect rect);

src/Avalonia.Input/IPointer.cs

@@ -15,10 +15,4 @@ namespace Avalonia.Input
         Mouse,
         Touch
     }
-
-    public class PointerIds
-    {
-        private static int s_nextPointerId = 1000;
-        public static int Next() => s_nextPointerId++;
-    }
 }

src/Avalonia.Input/IPointerDevice.cs

@@ -1,16 +1,20 @@
 // Copyright (c) The Avalonia Project. All rights reserved.
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
+using System;
 using Avalonia.VisualTree;
 
 namespace Avalonia.Input
 {
     public interface IPointerDevice : IInputDevice
     {
+        [Obsolete("Use IPointer")]
         IInputElement Captured { get; }
-
+        
+        [Obsolete("Use IPointer")]
         void Capture(IInputElement control);
 
+        [Obsolete("Use PointerEventArgs.GetPosition")]
         Point GetPosition(IVisual relativeTo);
     }
 }

src/Avalonia.Input/MouseDevice.cs

@@ -24,7 +24,7 @@ namespace Avalonia.Input
 
         PointerType IPointer.Type => PointerType.Mouse;
         bool IPointer.IsPrimary => true;
-        int IPointer.Id { get; } = PointerIds.Next();
+        int IPointer.Id { get; } = Pointer.GetNextFreeId();
         
         /// <summary>
         /// Gets the control that is currently capturing by the mouse, if any.
@@ -100,7 +100,7 @@ namespace Avalonia.Input
 
         public void ProcessRawEvent(RawInputEventArgs e)
         {
-            if (!e.Handled && e is RawMouseEventArgs margs)
+            if (!e.Handled && e is RawPointerEventArgs margs)
                 ProcessRawEvent(margs);
         }
 
@@ -133,7 +133,7 @@ namespace Avalonia.Input
             return rv;
         }
         
-        private void ProcessRawEvent(RawMouseEventArgs e)
+        private void ProcessRawEvent(RawPointerEventArgs e)
         {
             Contract.Requires<ArgumentNullException>(e != null);
 
@@ -143,30 +143,30 @@ namespace Avalonia.Input
             var props = CreateProperties(e);
             switch (e.Type)
             {
-                case RawMouseEventType.LeaveWindow:
+                case RawPointerEventType.LeaveWindow:
                     LeaveWindow(mouse, e.Root, e.InputModifiers);
                     break;
-                case RawMouseEventType.LeftButtonDown:
-                case RawMouseEventType.RightButtonDown:
-                case RawMouseEventType.MiddleButtonDown:
+                case RawPointerEventType.LeftButtonDown:
+                case RawPointerEventType.RightButtonDown:
+                case RawPointerEventType.MiddleButtonDown:
                     if (ButtonCount(props) > 1)
                         e.Handled = MouseMove(mouse, e.Root, e.Position, props, e.InputModifiers);
                     else
                         e.Handled = MouseDown(mouse, e.Timestamp, e.Root, e.Position,
                             props, e.InputModifiers);
                     break;
-                case RawMouseEventType.LeftButtonUp:
-                case RawMouseEventType.RightButtonUp:
-                case RawMouseEventType.MiddleButtonUp:
+                case RawPointerEventType.LeftButtonUp:
+                case RawPointerEventType.RightButtonUp:
+                case RawPointerEventType.MiddleButtonUp:
                     if (ButtonCount(props) != 0)
                         e.Handled = MouseMove(mouse, e.Root, e.Position, props, e.InputModifiers);
                     else
                         e.Handled = MouseUp(mouse, e.Root, e.Position, props, e.InputModifiers);
                     break;
-                case RawMouseEventType.Move:
+                case RawPointerEventType.Move:
                     e.Handled = MouseMove(mouse, e.Root, e.Position, props, e.InputModifiers);
                     break;
-                case RawMouseEventType.Wheel:
+                case RawPointerEventType.Wheel:
                     e.Handled = MouseWheel(mouse, e.Root, e.Position, props, ((RawMouseWheelEventArgs)e).Delta, e.InputModifiers);
                     break;
             }
@@ -181,21 +181,21 @@ namespace Avalonia.Input
         }
 
 
-        PointerPointProperties CreateProperties(RawMouseEventArgs args)
+        PointerPointProperties CreateProperties(RawPointerEventArgs args)
         {
             var rv = new PointerPointProperties(args.InputModifiers);
 
-            if (args.Type == RawMouseEventType.LeftButtonDown)
+            if (args.Type == RawPointerEventType.LeftButtonDown)
                 rv.IsLeftButtonPressed = true;
-            if (args.Type == RawMouseEventType.MiddleButtonDown)
+            if (args.Type == RawPointerEventType.MiddleButtonDown)
                 rv.IsMiddleButtonPressed = true;
-            if (args.Type == RawMouseEventType.RightButtonDown)
+            if (args.Type == RawPointerEventType.RightButtonDown)
                 rv.IsRightButtonPressed = true;
-            if (args.Type == RawMouseEventType.LeftButtonUp)
+            if (args.Type == RawPointerEventType.LeftButtonUp)
                 rv.IsLeftButtonPressed = false;
-            if (args.Type == RawMouseEventType.MiddleButtonUp)
+            if (args.Type == RawPointerEventType.MiddleButtonUp)
                 rv.IsMiddleButtonPressed = false;
-            if (args.Type == RawMouseEventType.RightButtonDown)
+            if (args.Type == RawPointerEventType.RightButtonDown)
                 rv.IsRightButtonPressed = false;
             return rv;
         }

src/Avalonia.Input/Pointer.cs

@@ -6,6 +6,9 @@ namespace Avalonia.Input
 {
     public class Pointer : IPointer, IDisposable
     {
+        private static int s_NextFreePointerId = 1000;
+        public static int GetNextFreeId() => s_NextFreePointerId++;
+        
         public Pointer(int id, PointerType type, bool isPrimary, IInputElement implicitlyCaptured)
         {
             Id = id;
@@ -57,4 +60,4 @@ namespace Avalonia.Input
                 Captured.DetachedFromVisualTree -= OnCaptureDetached;
         }
     }
-}
+}

src/Avalonia.Input/Raw/RawMouseWheelEventArgs.cs

@@ -4,7 +4,7 @@
 
 namespace Avalonia.Input.Raw
 {
-    public class RawMouseWheelEventArgs : RawMouseEventArgs
+    public class RawMouseWheelEventArgs : RawPointerEventArgs
     {
         public RawMouseWheelEventArgs(
             IInputDevice device,
@@ -12,7 +12,7 @@ namespace Avalonia.Input.Raw
             IInputRoot root,
             Point position,
             Vector delta, InputModifiers inputModifiers)
-            : base(device, timestamp, root, RawMouseEventType.Wheel, position, inputModifiers)
+            : base(device, timestamp, root, RawPointerEventType.Wheel, position, inputModifiers)
         {
             Delta = delta;
         }

src/Avalonia.Input/Raw/RawMouseEventArgs.cs → src/Avalonia.Input/Raw/RawPointerEventArgs.cs

@@ -5,7 +5,7 @@ using System;
 
 namespace Avalonia.Input.Raw
 {
-    public enum RawMouseEventType
+    public enum RawPointerEventType
     {
         LeaveWindow,
         LeftButtonDown,
@@ -25,10 +25,10 @@ namespace Avalonia.Input.Raw
     /// <summary>
     /// A raw mouse event.
     /// </summary>
-    public class RawMouseEventArgs : RawInputEventArgs
+    public class RawPointerEventArgs : RawInputEventArgs
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="RawMouseEventArgs"/> class.
+        /// Initializes a new instance of the <see cref="RawPointerEventArgs"/> class.
         /// </summary>
         /// <param name="device">The associated device.</param>
         /// <param name="timestamp">The event timestamp.</param>
@@ -36,11 +36,11 @@ namespace Avalonia.Input.Raw
         /// <param name="type">The type of the event.</param>
         /// <param name="position">The mouse position, in client DIPs.</param>
         /// <param name="inputModifiers">The input modifiers.</param>
-        public RawMouseEventArgs(
+        public RawPointerEventArgs(
             IInputDevice device,
             ulong timestamp,
             IInputRoot root,
-            RawMouseEventType type,
+            RawPointerEventType type,
             Point position, 
             InputModifiers inputModifiers)
             : base(device, timestamp)
@@ -67,7 +67,7 @@ namespace Avalonia.Input.Raw
         /// <summary>
         /// Gets the type of the event.
         /// </summary>
-        public RawMouseEventType Type { get; private set; }
+        public RawPointerEventType Type { get; private set; }
 
         /// <summary>
         /// Gets the input modifiers.

src/Avalonia.Input/Raw/RawTouchEventArgs.cs

@@ -1,9 +1,9 @@
 namespace Avalonia.Input.Raw
 {
-    public class RawTouchEventArgs : RawMouseEventArgs
+    public class RawTouchEventArgs : RawPointerEventArgs
     {
         public RawTouchEventArgs(IInputDevice device, ulong timestamp, IInputRoot root,
-            RawMouseEventType type, Point position, InputModifiers inputModifiers,
+            RawPointerEventType type, Point position, InputModifiers inputModifiers,
             long touchPointId) 
             : base(device, timestamp, root, type, position, inputModifiers)
         {

src/Avalonia.Input/TouchDevice.cs

@@ -7,7 +7,9 @@ namespace Avalonia.Input
 {
     /// <summary>
     /// Handles raw touch events
-    /// This class is supposed to be used on per-toplevel basis, don't event try to have a global instance
+    /// <remarks>
+    /// This class is supposed to be used on per-toplevel basis, don't use a shared one
+    /// </remarks>
     /// </summary>
     public class TouchDevice : IInputDevice
     {
@@ -28,17 +30,17 @@ namespace Avalonia.Input
             var args = (RawTouchEventArgs)ev;
             if (!_pointers.TryGetValue(args.TouchPointId, out var pointer))
             {
-                if (args.Type == RawMouseEventType.TouchEnd)
+                if (args.Type == RawPointerEventType.TouchEnd)
                     return;
                 var hit = args.Root.InputHitTest(args.Position);
 
-                _pointers[args.TouchPointId] = pointer = new Pointer(PointerIds.Next(),
+                _pointers[args.TouchPointId] = pointer = new Pointer(Pointer.GetNextFreeId(),
                     PointerType.Touch, _pointers.Count == 0, hit);
             }
             
 
             var target = pointer.GetEffectiveCapture() ?? args.Root;
-            if (args.Type == RawMouseEventType.TouchBegin)
+            if (args.Type == RawPointerEventType.TouchBegin)
             {
                 var modifiers = GetModifiers(args.InputModifiers, pointer.IsPrimary);
                 target.RaiseEvent(new PointerPressedEventArgs(target, pointer,
@@ -46,7 +48,7 @@ namespace Avalonia.Input
                     modifiers));
             }
 
-            if (args.Type == RawMouseEventType.TouchEnd)
+            if (args.Type == RawPointerEventType.TouchEnd)
             {
                 _pointers.Remove(args.TouchPointId);
                 var modifiers = GetModifiers(args.InputModifiers, false);
@@ -58,7 +60,7 @@ namespace Avalonia.Input
                 }
             }
 
-            if (args.Type == RawMouseEventType.TouchUpdate)
+            if (args.Type == RawPointerEventType.TouchUpdate)
             {
                 var modifiers = GetModifiers(args.InputModifiers, pointer.IsPrimary);
                 target.RaiseEvent(new PointerEventArgs(InputElement.PointerMovedEvent, target, pointer, args.Root,

src/Avalonia.Native/WindowImplBase.cs

@@ -226,7 +226,7 @@ namespace Avalonia.Native
                     break;
 
                 default:
-                    Input?.Invoke(new RawMouseEventArgs(_mouse, timeStamp, _inputRoot, (RawMouseEventType)type, point.ToAvaloniaPoint(), (InputModifiers)modifiers));
+                    Input?.Invoke(new RawPointerEventArgs(_mouse, timeStamp, _inputRoot, (RawPointerEventType)type, point.ToAvaloniaPoint(), (InputModifiers)modifiers));
                     break;
             }
         }

src/Avalonia.X11/X11Window.cs

@@ -314,9 +314,9 @@ namespace Avalonia.X11
             else if (ev.type == XEventName.FocusOut)
                 Deactivated?.Invoke();
             else if (ev.type == XEventName.MotionNotify)
-                MouseEvent(RawMouseEventType.Move, ref ev, ev.MotionEvent.state);
+                MouseEvent(RawPointerEventType.Move, ref ev, ev.MotionEvent.state);
             else if (ev.type == XEventName.LeaveNotify)
-                MouseEvent(RawMouseEventType.LeaveWindow, ref ev, ev.CrossingEvent.state);
+                MouseEvent(RawPointerEventType.LeaveWindow, ref ev, ev.CrossingEvent.state);
             else if (ev.type == XEventName.PropertyNotify)
             {
                 OnPropertyChange(ev.PropertyEvent.atom, ev.PropertyEvent.state == 0);
@@ -326,9 +326,9 @@ namespace Avalonia.X11
                 if (ActivateTransientChildIfNeeded())
                     return;
                 if (ev.ButtonEvent.button < 4)
-                    MouseEvent(ev.ButtonEvent.button == 1 ? RawMouseEventType.LeftButtonDown
-                        : ev.ButtonEvent.button == 2 ? RawMouseEventType.MiddleButtonDown
-                        : RawMouseEventType.RightButtonDown, ref ev, ev.ButtonEvent.state);
+                    MouseEvent(ev.ButtonEvent.button == 1 ? RawPointerEventType.LeftButtonDown
+                        : ev.ButtonEvent.button == 2 ? RawPointerEventType.MiddleButtonDown
+                        : RawPointerEventType.RightButtonDown, ref ev, ev.ButtonEvent.state);
                 else
                 {
                     var delta = ev.ButtonEvent.button == 4
@@ -347,9 +347,9 @@ namespace Avalonia.X11
             else if (ev.type == XEventName.ButtonRelease)
             {
                 if (ev.ButtonEvent.button < 4)
-                    MouseEvent(ev.ButtonEvent.button == 1 ? RawMouseEventType.LeftButtonUp
-                        : ev.ButtonEvent.button == 2 ? RawMouseEventType.MiddleButtonUp
-                        : RawMouseEventType.RightButtonUp, ref ev, ev.ButtonEvent.state);
+                    MouseEvent(ev.ButtonEvent.button == 1 ? RawPointerEventType.LeftButtonUp
+                        : ev.ButtonEvent.button == 2 ? RawPointerEventType.MiddleButtonUp
+                        : RawPointerEventType.RightButtonUp, ref ev, ev.ButtonEvent.state);
             }
             else if (ev.type == XEventName.ConfigureNotify)
             {
@@ -577,7 +577,7 @@ namespace Avalonia.X11
 
         public void ScheduleInput(RawInputEventArgs args)
         {
-            if (args is RawMouseEventArgs mouse)
+            if (args is RawPointerEventArgs mouse)
                 mouse.Position = mouse.Position / Scaling;
             if (args is RawDragEvent drag)
                 drag.Location = drag.Location / Scaling;
@@ -598,13 +598,13 @@ namespace Avalonia.X11
             }
         }
         
-        void MouseEvent(RawMouseEventType type, ref XEvent ev, XModifierMask mods)
+        void MouseEvent(RawPointerEventType type, ref XEvent ev, XModifierMask mods)
         {
-            var mev = new RawMouseEventArgs(
+            var mev = new RawPointerEventArgs(
                 _mouse, (ulong)ev.ButtonEvent.time.ToInt64(), _inputRoot,
                 type, new Point(ev.ButtonEvent.x, ev.ButtonEvent.y), TranslateModifiers(mods)); 
-            if(type == RawMouseEventType.Move && _inputQueue.Count>0 && _lastEvent.Event is RawMouseEventArgs ma)
-                if (ma.Type == RawMouseEventType.Move)
+            if(type == RawPointerEventType.Move && _inputQueue.Count>0 && _lastEvent.Event is RawPointerEventArgs ma)
+                if (ma.Type == RawPointerEventType.Move)
                 {
                     _lastEvent.Event = mev;
                     return;

src/Avalonia.X11/XI2Manager.cs

@@ -182,10 +182,10 @@ namespace Avalonia.X11
                 || ev.Type == XiEventType.XI_TouchEnd)
             {
                 var type = ev.Type == XiEventType.XI_TouchBegin ?
-                    RawMouseEventType.TouchBegin :
+                    RawPointerEventType.TouchBegin :
                     (ev.Type == XiEventType.XI_TouchUpdate ?
-                        RawMouseEventType.TouchUpdate :
-                        RawMouseEventType.TouchEnd);
+                        RawPointerEventType.TouchUpdate :
+                        RawPointerEventType.TouchEnd);
                 client.ScheduleInput(new RawTouchEventArgs(_touchDevice,
                     ev.Timestamp, client.InputRoot, type, ev.Position, ev.Modifiers, ev.Detail));
                 return;
@@ -223,20 +223,20 @@ namespace Avalonia.X11
                     client.ScheduleInput(new RawMouseWheelEventArgs(_platform.MouseDevice, ev.Timestamp,
                         client.InputRoot, ev.Position, scrollDelta, ev.Modifiers));
                 if (_pointerDevice.HasMotion(ev))
-                    client.ScheduleInput(new RawMouseEventArgs(_platform.MouseDevice, ev.Timestamp, client.InputRoot,
-                        RawMouseEventType.Move, ev.Position, ev.Modifiers));
+                    client.ScheduleInput(new RawPointerEventArgs(_platform.MouseDevice, ev.Timestamp, client.InputRoot,
+                        RawPointerEventType.Move, ev.Position, ev.Modifiers));
             }
 
             if (ev.Type == XiEventType.XI_ButtonPress || ev.Type == XiEventType.XI_ButtonRelease)
             {
                 var down = ev.Type == XiEventType.XI_ButtonPress;
                 var type =
-                    ev.Button == 1 ? (down ? RawMouseEventType.LeftButtonDown : RawMouseEventType.LeftButtonUp)
-                    : ev.Button == 2 ? (down ? RawMouseEventType.MiddleButtonDown : RawMouseEventType.MiddleButtonUp)
-                    : ev.Button == 3 ? (down ? RawMouseEventType.RightButtonDown : RawMouseEventType.RightButtonUp)
-                    : (RawMouseEventType?)null;
+                    ev.Button == 1 ? (down ? RawPointerEventType.LeftButtonDown : RawPointerEventType.LeftButtonUp)
+                    : ev.Button == 2 ? (down ? RawPointerEventType.MiddleButtonDown : RawPointerEventType.MiddleButtonUp)
+                    : ev.Button == 3 ? (down ? RawPointerEventType.RightButtonDown : RawPointerEventType.RightButtonUp)
+                    : (RawPointerEventType?)null;
                 if (type.HasValue)
-                    client.ScheduleInput(new RawMouseEventArgs(_platform.MouseDevice, ev.Timestamp, client.InputRoot,
+                    client.ScheduleInput(new RawPointerEventArgs(_platform.MouseDevice, ev.Timestamp, client.InputRoot,
                         type.Value, ev.Position, ev.Modifiers));
             }
             

src/Gtk/Avalonia.Gtk3/WindowBaseImpl.cs

@@ -145,17 +145,17 @@ namespace Avalonia.Gtk3
         private unsafe bool OnButton(IntPtr w, IntPtr ev, IntPtr userdata)
         {
             var evnt = (GdkEventButton*)ev;
-            var e = new RawMouseEventArgs(
+            var e = new RawPointerEventArgs(
                 Gtk3Platform.Mouse,
                 evnt->time,
                 _inputRoot,
                 evnt->type == GdkEventType.ButtonRelease
                     ? evnt->button == 1
-                        ? RawMouseEventType.LeftButtonUp
-                        : evnt->button == 3 ? RawMouseEventType.RightButtonUp : RawMouseEventType.MiddleButtonUp
+                        ? RawPointerEventType.LeftButtonUp
+                        : evnt->button == 3 ? RawPointerEventType.RightButtonUp : RawPointerEventType.MiddleButtonUp
                     : evnt->button == 1
-                        ? RawMouseEventType.LeftButtonDown
-                        : evnt->button == 3 ? RawMouseEventType.RightButtonDown : RawMouseEventType.MiddleButtonDown,
+                        ? RawPointerEventType.LeftButtonDown
+                        : evnt->button == 3 ? RawPointerEventType.RightButtonDown : RawPointerEventType.MiddleButtonDown,
                 new Point(evnt->x, evnt->y), GetModifierKeys(evnt->state));
             OnInput(e);
             return true;
@@ -179,11 +179,11 @@ namespace Avalonia.Gtk3
             var evnt = (GdkEventMotion*)ev;
             var position = new Point(evnt->x, evnt->y);
             Native.GdkEventRequestMotions(ev);
-            var e = new RawMouseEventArgs(
+            var e = new RawPointerEventArgs(
                 Gtk3Platform.Mouse,
                 evnt->time,
                 _inputRoot,
-                RawMouseEventType.Move,
+                RawPointerEventType.Move,
                 position, GetModifierKeys(evnt->state));
             OnInput(e);
             
@@ -237,10 +237,10 @@ namespace Avalonia.Gtk3
         {
             var evnt = (GdkEventCrossing*) pev;
             var position = new Point(evnt->x, evnt->y);
-            OnInput(new RawMouseEventArgs(Gtk3Platform.Mouse,
+            OnInput(new RawPointerEventArgs(Gtk3Platform.Mouse,
                 evnt->time,
                 _inputRoot,
-                RawMouseEventType.Move,
+                RawPointerEventType.Move,
                 position, GetModifierKeys(evnt->state)));
             return true;
         }

src/Linux/Avalonia.LinuxFramebuffer/Mice.cs

@@ -76,9 +76,9 @@ namespace Avalonia.LinuxFramebuffer
                     _y = Math.Min(_height, Math.Max(0, _y + ev.value));
                 else
                     return;
-                Event?.Invoke(new RawMouseEventArgs(LinuxFramebufferPlatform.MouseDevice,
+                Event?.Invoke(new RawPointerEventArgs(LinuxFramebufferPlatform.MouseDevice,
                     LinuxFramebufferPlatform.Timestamp,
-                    LinuxFramebufferPlatform.TopLevel.InputRoot, RawMouseEventType.Move, new Point(_x, _y),
+                    LinuxFramebufferPlatform.TopLevel.InputRoot, RawPointerEventType.Move, new Point(_x, _y),
                     InputModifiers.None));
             }
             if (ev.type ==(int) EvType.EV_ABS)
@@ -89,24 +89,24 @@ namespace Avalonia.LinuxFramebuffer
                     _y = TranslateAxis(device.AbsY.Value, ev.value, _height);
                 else
                     return;
-                Event?.Invoke(new RawMouseEventArgs(LinuxFramebufferPlatform.MouseDevice,
+                Event?.Invoke(new RawPointerEventArgs(LinuxFramebufferPlatform.MouseDevice,
                     LinuxFramebufferPlatform.Timestamp,
-                    LinuxFramebufferPlatform.TopLevel.InputRoot, RawMouseEventType.Move, new Point(_x, _y),
+                    LinuxFramebufferPlatform.TopLevel.InputRoot, RawPointerEventType.Move, new Point(_x, _y),
                     InputModifiers.None));
             }
             if (ev.type == (short) EvType.EV_KEY)
             {
-                RawMouseEventType? type = null;
+                RawPointerEventType? type = null;
                 if (ev.code == (ushort) EvKey.BTN_LEFT)
-                    type = ev.value == 1 ? RawMouseEventType.LeftButtonDown : RawMouseEventType.LeftButtonUp;
+                    type = ev.value == 1 ? RawPointerEventType.LeftButtonDown : RawPointerEventType.LeftButtonUp;
                 if (ev.code == (ushort)EvKey.BTN_RIGHT)
-                    type = ev.value == 1 ? RawMouseEventType.RightButtonDown : RawMouseEventType.RightButtonUp;
+                    type = ev.value == 1 ? RawPointerEventType.RightButtonDown : RawPointerEventType.RightButtonUp;
                 if (ev.code == (ushort) EvKey.BTN_MIDDLE)
-                    type = ev.value == 1 ? RawMouseEventType.MiddleButtonDown : RawMouseEventType.MiddleButtonUp;
+                    type = ev.value == 1 ? RawPointerEventType.MiddleButtonDown : RawPointerEventType.MiddleButtonUp;
                 if (!type.HasValue)
                     return;
 
-                Event?.Invoke(new RawMouseEventArgs(LinuxFramebufferPlatform.MouseDevice,
+                Event?.Invoke(new RawPointerEventArgs(LinuxFramebufferPlatform.MouseDevice,
                     LinuxFramebufferPlatform.Timestamp,
                     LinuxFramebufferPlatform.TopLevel.InputRoot, type.Value, new Point(_x, _y), default(InputModifiers)));
             }

src/Windows/Avalonia.Win32/WindowImpl.cs

@@ -532,15 +532,15 @@ namespace Avalonia.Win32
                 case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN:
                     if(ShouldIgnoreTouchEmulatedMessage())
                         break;
-                    e = new RawMouseEventArgs(
+                    e = new RawPointerEventArgs(
                         WindowsMouseDevice.Instance,
                         timestamp,
                         _owner,
                         msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN
-                            ? RawMouseEventType.LeftButtonDown
+                            ? RawPointerEventType.LeftButtonDown
                             : msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN
-                                ? RawMouseEventType.RightButtonDown
-                                : RawMouseEventType.MiddleButtonDown,
+                                ? RawPointerEventType.RightButtonDown
+                                : RawPointerEventType.MiddleButtonDown,
                         DipFromLParam(lParam), GetMouseModifiers(wParam));
                     break;
 
@@ -549,15 +549,15 @@ namespace Avalonia.Win32
                 case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP:
                     if(ShouldIgnoreTouchEmulatedMessage())
                         break;
-                    e = new RawMouseEventArgs(
+                    e = new RawPointerEventArgs(
                         WindowsMouseDevice.Instance,
                         timestamp,
                         _owner,
                         msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONUP
-                            ? RawMouseEventType.LeftButtonUp
+                            ? RawPointerEventType.LeftButtonUp
                             : msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONUP
-                                ? RawMouseEventType.RightButtonUp
-                                : RawMouseEventType.MiddleButtonUp,
+                                ? RawPointerEventType.RightButtonUp
+                                : RawPointerEventType.MiddleButtonUp,
                         DipFromLParam(lParam), GetMouseModifiers(wParam));
                     break;
 
@@ -577,11 +577,11 @@ namespace Avalonia.Win32
                         UnmanagedMethods.TrackMouseEvent(ref tm);
                     }
 
-                    e = new RawMouseEventArgs(
+                    e = new RawPointerEventArgs(
                         WindowsMouseDevice.Instance,
                         timestamp,
                         _owner,
-                        RawMouseEventType.Move,
+                        RawPointerEventType.Move,
                         DipFromLParam(lParam), GetMouseModifiers(wParam));
 
                     break;
@@ -606,26 +606,26 @@ namespace Avalonia.Win32
 
                 case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE:
                     _trackingMouse = false;
-                    e = new RawMouseEventArgs(
+                    e = new RawPointerEventArgs(
                         WindowsMouseDevice.Instance,
                         timestamp,
                         _owner,
-                        RawMouseEventType.LeaveWindow,
+                        RawPointerEventType.LeaveWindow,
                         new Point(), WindowsKeyboardDevice.Instance.Modifiers);
                     break;
 
                 case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN:
                 case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN:
                 case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN:
-                    e = new RawMouseEventArgs(
+                    e = new RawPointerEventArgs(
                         WindowsMouseDevice.Instance,
                         timestamp,
                         _owner,
                         msg == (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN
-                            ? RawMouseEventType.NonClientLeftButtonDown
+                            ? RawPointerEventType.NonClientLeftButtonDown
                             : msg == (int)UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN
-                                ? RawMouseEventType.RightButtonDown
-                                : RawMouseEventType.MiddleButtonDown,
+                                ? RawPointerEventType.RightButtonDown
+                                : RawPointerEventType.MiddleButtonDown,
                         new Point(0, 0), GetMouseModifiers(wParam));
                     break;
                 case WindowsMessage.WM_TOUCH:
@@ -639,10 +639,10 @@ namespace Avalonia.Win32
                             Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
                                 _owner,
                                 touchInput.Flags.HasFlag(TouchInputFlags.TOUCHEVENTF_UP) ?
-                                    RawMouseEventType.TouchEnd :
+                                    RawPointerEventType.TouchEnd :
                                     touchInput.Flags.HasFlag(TouchInputFlags.TOUCHEVENTF_DOWN) ?
-                                        RawMouseEventType.TouchBegin :
-                                        RawMouseEventType.TouchUpdate,
+                                        RawPointerEventType.TouchBegin :
+                                        RawPointerEventType.TouchUpdate,
                                 new Point(pt.X, pt.Y),
                                 WindowsKeyboardDevice.Instance.Modifiers,
                                 touchInput.Id));

tests/Avalonia.Controls.UnitTests/MouseTestHelper.cs

@@ -9,7 +9,7 @@ namespace Avalonia.Controls.UnitTests
 
         class TestPointer : IPointer
         {
-            public int Id { get; } = PointerIds.Next();
+            public int Id { get; } = Pointer.GetNextFreeId();
 
             public void Capture(IInputElement control)
             {

tests/Avalonia.Controls.UnitTests/Platform/DefaultMenuInteractionHandlerTests.cs

@@ -12,7 +12,7 @@ namespace Avalonia.Controls.UnitTests.Platform
     {
         class FakePointer : IPointer
         {
-            public int Id { get; } = PointerIds.Next();
+            public int Id { get; } = Pointer.GetNextFreeId();
 
             public void Capture(IInputElement control)
             {

tests/Avalonia.Input.UnitTests/MouseDeviceTests.cs

@@ -225,11 +225,11 @@ namespace Avalonia.Input.UnitTests
 
         private void SendMouseMove(IInputManager inputManager, TestRoot root, Point p = new Point())
         {
-            inputManager.ProcessInput(new RawMouseEventArgs(
+            inputManager.ProcessInput(new RawPointerEventArgs(
                 root.MouseDevice,
                 0,
                 root,
-                RawMouseEventType.Move,
+                RawPointerEventType.Move,
                 p,
                 InputModifiers.None));
         }