feat: Support ContactRect in X11 and Windows platform (AvaloniaUI#16498)

lindexi · walterlv · commit 27ad98bb3d98 · 2025-02-06T16:40:01.000+08:00
* feat: Support ContactRect in X11 platform

* Provide compat value for ContactRect property

* Using touch position to get the screen.

* Try get the correct screen

* Remove the code of log.

* Improve performance avoid the GC stress.

* Add a second overload in PointerPointProperties to avoid break API change

* Support touch size in WM_Touch

* Support get ContactRect in WM_POINTER

* Fix the coordinate of touch contact area

* Fix the calcuate of WM_Touch contact area

* Fix the X11 area contact

* Fix the touch major and minor default value is not null.

The XIValuatorClassInfo is struct, so the FirstOrDefault will return the default struct when not found.
diff --git a/src/Avalonia.Base/Input/PenDevice.cs b/src/Avalonia.Base/Input/PenDevice.cs
@@ -52,7 +52,7 @@ private void ProcessRawEvent(RawPointerEventArgs e)
             }
             
             var props = new PointerPointProperties(e.InputModifiers, e.Type.ToUpdateKind(),
-                e.Point.Twist, e.Point.Pressure, e.Point.XTilt, e.Point.YTilt);
+                e.Point.Twist, e.Point.Pressure, e.Point.XTilt, e.Point.YTilt, e.Point.ContactRect);
             var keyModifiers = e.InputModifiers.ToKeyModifiers();
 
             bool shouldReleasePointer = false;
diff --git a/src/Avalonia.Base/Input/PointerPoint.cs b/src/Avalonia.Base/Input/PointerPoint.cs
@@ -35,6 +35,11 @@ public PointerPoint(IPointer pointer, Point position, PointerPointProperties pro
     /// </summary>
     public record struct PointerPointProperties
     {
+        /// <summary>
+        /// Gets the bounding rectangle of the contact area (typically from touch input).
+        /// </summary>
+        public Rect ContactRect { get; }
+
         /// <summary>
         /// Gets a value that indicates whether the pointer input was triggered by the primary action mode of an input device.
         /// </summary>
@@ -155,17 +160,22 @@ public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kin
         }
 
         public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind,
-            float twist, float pressure, float xTilt, float yTilt
-            ) : this (modifiers, kind)
+            float twist, float pressure, float xTilt, float yTilt) : this(modifiers, kind, twist, pressure, xTilt, yTilt, default)
+        {
+        }
+
+        public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind,
+            float twist, float pressure, float xTilt, float yTilt, Rect contactRect) : this(modifiers, kind)
         {
             Twist = twist;
             Pressure = pressure;
             XTilt = xTilt;
             YTilt = yTilt;
+            ContactRect = contactRect;
         }
 
         internal PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind, RawPointerPoint rawPoint)
-            : this(modifiers, kind, rawPoint.Twist, rawPoint.Pressure, rawPoint.XTilt, rawPoint.YTilt)
+            : this(modifiers, kind, rawPoint.Twist, rawPoint.Pressure, rawPoint.XTilt, rawPoint.YTilt, rawPoint.ContactRect)
         {
         }
 
diff --git a/src/Avalonia.Base/Input/Raw/RawPointerEventArgs.cs b/src/Avalonia.Base/Input/Raw/RawPointerEventArgs.cs
@@ -143,6 +143,14 @@ public record struct RawPointerPoint
         /// <inheritdoc cref="PointerPointProperties.YTilt" />
         public float YTilt { get; set; }
 
+        /// <inheritdoc cref="PointerPointProperties.ContactRect" />
+        public Rect ContactRect
+        {
+            get => _contactRect ?? new Rect(Position, new Size());
+            set => _contactRect = value;
+        }
+
+        private Rect? _contactRect;
 
         public RawPointerPoint()
         {
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
@@ -58,7 +58,7 @@ public void Initialize(X11PlatformOptions options)
             DeferredDisplay = XOpenDisplay(IntPtr.Zero);
             if (DeferredDisplay == IntPtr.Zero)
                 throw new Exception("XOpenDisplay failed");
-                
+
             OrphanedWindow = XCreateSimpleWindow(Display, XDefaultRootWindow(Display), 0, 0, 1, 1, 0, IntPtr.Zero,
                 IntPtr.Zero);
             XError.Init();
@@ -86,7 +86,7 @@ public void Initialize(X11PlatformOptions options)
                 .Bind<IPlatformIconLoader>().ToConstant(new X11IconLoader())
                 .Bind<IMountedVolumeInfoProvider>().ToConstant(new LinuxMountedVolumeInfoProvider())
                 .Bind<IPlatformLifetimeEventsImpl>().ToConstant(new X11PlatformLifetimeEvents(this));
-            
+
             Screens = X11Screens = new X11Screens(this);
             if (Info.XInputVersion != null)
             {
@@ -126,7 +126,7 @@ public ITrayIconImpl CreateTrayIcon()
 
             return dbusTrayIcon;
         }
-        
+
         public IWindowImpl CreateWindow()
         {
             return new X11Window(this, null);
@@ -145,11 +145,11 @@ private static bool EnableIme(X11PlatformOptions options)
             var avaloniaImModule = Environment.GetEnvironmentVariable("AVALONIA_IM_MODULE");
             if (avaloniaImModule == "none")
                 return false;
-            
+
             // Use value from options when specified
             if (options.EnableIme.HasValue)
                 return options.EnableIme.Value;
-            
+
             // Automatically enable for CJK locales
             var lang = Environment.GetEnvironmentVariable("LANG");
             var isCjkLocale = lang != null &&
@@ -168,7 +168,7 @@ private static bool ShouldUseXim()
                 || Environment.GetEnvironmentVariable("GTK_IM_MODULE") == "none"
                 || Environment.GetEnvironmentVariable("QT_IM_MODULE") == "none")
                 return true;
-            
+
             // Check if XIM is configured
             var modifiers = Environment.GetEnvironmentVariable("XMODIFIERS");
             if (modifiers == null)
@@ -177,16 +177,16 @@ private static bool ShouldUseXim()
                 return false;
             if (!modifiers.Contains("@im="))
                 return false;
-            
+
             // Check if we are configured to use it
             if (Environment.GetEnvironmentVariable("GTK_IM_MODULE") == "xim"
                 || Environment.GetEnvironmentVariable("QT_IM_MODULE") == "xim"
                 || Environment.GetEnvironmentVariable("AVALONIA_IM_MODULE") == "xim")
                 return true;
-            
+
             return false;
         }
-        
+
         private static IPlatformGraphics InitializeGraphics(X11PlatformOptions opts, X11Info info)
         {
             if (opts.RenderingMode is null || !opts.RenderingMode.Any())
@@ -200,7 +200,7 @@ private static IPlatformGraphics InitializeGraphics(X11PlatformOptions opts, X11
                 {
                     return null;
                 }
-                
+
                 if (renderingMode == X11RenderingMode.Glx)
                 {
                     if (GlxPlatformGraphics.TryCreate(info, opts.GlProfiles) is { } glx)
@@ -252,13 +252,13 @@ public enum X11RenderingMode
         /// Enables native Linux EGL rendering.
         /// </summary>
         Egl = 3,
-        
+
         /// <summary>
         /// Enables Vulkan rendering
         /// </summary>
         Vulkan = 4
     }
-    
+
     /// <summary>
     /// Platform-specific options which apply to Linux.
     /// </summary>
@@ -294,23 +294,23 @@ public class X11PlatformOptions
         /// The default value is true.
         /// </summary>
         public bool UseDBusFilePicker { get; set; } = true;
-        
+
         /// <summary>
         /// Determines whether to use IME.
         /// IME would be enabled by default if the current user input language is one of the following: Mandarin, Japanese, Vietnamese or Korean.
         /// </summary>
         /// <remarks>
-        /// Input method editor is a component that enables users to generate characters not natively available 
+        /// Input method editor is a component that enables users to generate characters not natively available
         /// on their input devices by using sequences of characters or mouse operations that are natively available on their input devices.
         /// </remarks>
         public bool? EnableIme { get; set; } = true;
 
         /// <summary>
         /// Determines whether to use Input Focus Proxy.
         /// The default value is false.
-        /// </summary> 
+        /// </summary>
         public bool EnableInputFocusProxy { get; set; }
-        
+
         /// <summary>
         /// Determines whether to enable support for the
         /// X Session Management Protocol.
@@ -320,7 +320,7 @@ public class X11PlatformOptions
         /// Linux systems that uses Xorg. This enables apps to control how they
         /// can control and/or cancel the pending shutdown requested by the user.
         /// </remarks>
-        public bool EnableSessionManagement { get; set; } = 
+        public bool EnableSessionManagement { get; set; } =
             Environment.GetEnvironmentVariable("AVALONIA_X11_USE_SESSION_MANAGEMENT") != "0";
 
         /// <summary>
@@ -353,7 +353,7 @@ public class X11PlatformOptions
             "SVGA3D"
         };
 
-        
+
         public string WmClass { get; set; }
 
         /// <summary>
@@ -368,7 +368,7 @@ public class X11PlatformOptions
         /// Retain window framebuffer contents if using CPU rendering mode.
         /// This will keep an offscreen bitmap for each window with contents of the previous frame
         /// While improving performance by saving a blit, it will increase memory consumption
-        /// if you have many windows 
+        /// if you have many windows
         /// </summary>
         public bool? UseRetainedFramebuffer { get; set; }
 
@@ -378,7 +378,7 @@ public class X11PlatformOptions
         /// Use this if you need to use GLib-based libraries on the main thread
         /// </summary>
         public bool UseGLibMainLoop { get; set; }
-        
+
         /// <summary>
         /// If Avalonia is in control of a run loop, we propagate exceptions by stopping the run loop frame
         /// and rethrowing an exception. However, if there is no Avalonia-controlled run loop frame,
@@ -387,7 +387,7 @@ public class X11PlatformOptions
         /// This property allows to inspect such exceptions before they will be ignored
         /// </summary>
         public Action<Exception>? ExterinalGLibMainLoopExceptionLogger { get; set; }
-        
+
         public X11PlatformOptions()
         {
             try
diff --git a/src/Avalonia.X11/XI2Manager.cs b/src/Avalonia.X11/XI2Manager.cs
@@ -1,8 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Runtime.InteropServices;
+
 using Avalonia.Input;
 using Avalonia.Input.Raw;
+using Avalonia.Platform;
 using static Avalonia.X11.XLib;
 
 namespace Avalonia.X11
@@ -97,13 +101,15 @@ public bool HasMotion(ParsedDeviceEvent ev)
         private AvaloniaX11Platform _platform;
 
         private XIValuatorClassInfo? _pressureXIValuatorClassInfo;
+        private XIValuatorClassInfo? _touchMajorXIValuatorClassInfo;
+        private XIValuatorClassInfo? _touchMinorXIValuatorClassInfo;
 
         public bool Init(AvaloniaX11Platform platform)
         {
             _platform = platform;
             _x11 = platform.Info;
             _multitouch = platform.Options?.EnableMultiTouch ?? true;
-            var devices =(XIDeviceInfo*) XIQueryDevice(_x11.Display,
+            var devices = (XIDeviceInfo*) XIQueryDevice(_x11.Display,
                 (int)XiPredefinedDeviceId.XIAllMasterDevices, out int num);
             for (var c = 0; c < num; c++)
             {
@@ -118,8 +124,31 @@ public bool Init(AvaloniaX11Platform platform)
 
             if (_multitouch)
             {
+                // ABS_MT_TOUCH_MAJOR ABS_MT_TOUCH_MINOR
+                // https://www.kernel.org/doc/html/latest/input/multi-touch-protocol.html
+                var touchMajorAtom = XInternAtom(_x11.Display, "Abs MT Touch Major", false);
+                var touchMinorAtom = XInternAtom(_x11.Display, "Abs MT Touch Minor", false);
+
                 var pressureAtom = XInternAtom(_x11.Display, "Abs MT Pressure", false);
-                _pressureXIValuatorClassInfo = _pointerDevice.Valuators.FirstOrDefault(t => t.Label == pressureAtom);
+
+                var pressureXIValuatorClassInfo = _pointerDevice.Valuators.FirstOrDefault(t => t.Label == pressureAtom);
+                if (pressureXIValuatorClassInfo.Label == pressureAtom)
+                {
+                    // Why check twice? The XIValuatorClassInfo is struct, so the FirstOrDefault will return the default struct when not found.
+                    _pressureXIValuatorClassInfo = pressureXIValuatorClassInfo;
+                }
+
+                var touchMajorXIValuatorClassInfo = _pointerDevice.Valuators.FirstOrDefault(t => t.Label == touchMajorAtom);
+                if (touchMajorXIValuatorClassInfo.Label == touchMajorAtom)
+                {
+                    _touchMajorXIValuatorClassInfo = touchMajorXIValuatorClassInfo;
+                }
+
+                var touchMinorXIValuatorClassInfo = _pointerDevice.Valuators.FirstOrDefault(t => t.Label == touchMinorAtom);
+                if (touchMinorXIValuatorClassInfo.Label == touchMinorAtom)
+                {
+                    _touchMinorXIValuatorClassInfo = touchMinorXIValuatorClassInfo;
+                }
             }
 
             /*
@@ -256,6 +285,57 @@ private void OnDeviceEvent(IXI2Client client, ParsedDeviceEvent ev)
                     }
                 }
 
+                if(_touchMajorXIValuatorClassInfo is {} touchMajorXIValuatorClassInfo)
+                {
+                    double? touchMajor = null;
+                    double? touchMinor = null;
+                    PixelRect screenBounds = default;
+                    if (ev.Valuators.TryGetValue(touchMajorXIValuatorClassInfo.Number, out var touchMajorValue))
+                    {
+                        var pixelPoint = new PixelPoint((int)ev.RootPosition.X, (int)ev.RootPosition.Y);
+                        var screen = _platform.Screens.ScreenFromPoint(pixelPoint);
+                        var screenBoundsFromPoint = screen?.Bounds;
+                        Debug.Assert(screenBoundsFromPoint != null);
+                        if (screenBoundsFromPoint != null)
+                        {
+                            screenBounds = screenBoundsFromPoint.Value;
+
+                            // As https://www.kernel.org/doc/html/latest/input/multi-touch-protocol.html says, using `screenBounds.Width` is not accurate enough.
+                            touchMajor = (touchMajorValue - touchMajorXIValuatorClassInfo.Min) /
+                                (touchMajorXIValuatorClassInfo.Max - touchMajorXIValuatorClassInfo.Min) * screenBounds.Width;
+                        }
+                    }
+
+                    if (touchMajor != null)
+                    {
+                        if(_touchMinorXIValuatorClassInfo is {} touchMinorXIValuatorClassInfo)
+                        {
+                            if (ev.Valuators.TryGetValue(touchMinorXIValuatorClassInfo.Number, out var touchMinorValue))
+                            {
+                                touchMinor = (touchMinorValue - touchMinorXIValuatorClassInfo.Min) /
+                                             (touchMinorXIValuatorClassInfo.Max - touchMinorXIValuatorClassInfo.Min) * screenBounds.Height;
+                            }
+                        }
+
+                        if (touchMinor == null)
+                        {
+                            touchMinor = touchMajor;
+                        }
+
+                        var center = ev.Position;
+                        var leftX = center.X - touchMajor.Value / 2;
+                        var topY = center.Y - touchMinor.Value / 2;
+
+                        rawPointerPoint.ContactRect = new Rect
+                        (
+                            leftX,
+                            topY,
+                            touchMajor.Value,
+                            touchMinor.Value
+                        );
+                    }
+                }
+
                 client.ScheduleXI2Input(new RawTouchEventArgs(client.TouchDevice,
                     ev.Timestamp, client.InputRoot, type, rawPointerPoint, ev.Modifiers, ev.Detail));
                 return;
@@ -340,6 +420,7 @@ internal unsafe class ParsedDeviceEvent
         public RawInputModifiers Modifiers { get; }
         public ulong Timestamp { get; }
         public Point Position { get; }
+        public Point RootPosition { get; }
         public int Button { get; set; }
         public int Detail { get; set; }
         public bool Emulated { get; set; }
@@ -385,6 +466,7 @@ public ParsedDeviceEvent(XIDeviceEvent* ev)
 
             Valuators = new Dictionary<int, double>();
             Position = new Point(ev->event_x, ev->event_y);
+            RootPosition = new Point(ev->root_x, ev->root_y);
             var values = ev->valuators.Values;
             if(ev->valuators.Mask != null)
                 for (var c = 0; c < ev->valuators.MaskLen * 8; c++)
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ private void ProcessRawEvent(RawPointerEventArgs e)`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`var props = new PointerPointProperties(e.InputModifiers, e.Type.ToUpdateKind(),`
`55`		`- e.Point.Twist, e.Point.Pressure, e.Point.XTilt, e.Point.YTilt);`
	`55`	`+ e.Point.Twist, e.Point.Pressure, e.Point.XTilt, e.Point.YTilt, e.Point.ContactRect);`
`56`	`56`	`var keyModifiers = e.InputModifiers.ToKeyModifiers();`
`57`	`57`
`58`	`58`	`bool shouldReleasePointer = false;`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,11 @@ public PointerPoint(IPointer pointer, Point position, PointerPointProperties pro`
`35`	`35`	`/// </summary>`
`36`	`36`	`public record struct PointerPointProperties`
`37`	`37`	`{`
	`38`	`+ /// <summary>`
	`39`	`+ /// Gets the bounding rectangle of the contact area (typically from touch input).`
	`40`	`+ /// </summary>`
	`41`	`+ public Rect ContactRect { get; }`
	`42`	`+`
`38`	`43`	`/// <summary>`
`39`	`44`	`/// Gets a value that indicates whether the pointer input was triggered by the primary action mode of an input device.`
`40`	`45`	`/// </summary>`
`@@ -155,17 +160,22 @@ public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kin`
`155`	`160`	`}`
`156`	`161`
`157`	`162`	`public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind,`
`158`		`- float twist, float pressure, float xTilt, float yTilt`
`159`		`- ) : this (modifiers, kind)`
	`163`	`+ float twist, float pressure, float xTilt, float yTilt) : this(modifiers, kind, twist, pressure, xTilt, yTilt, default)`
	`164`	`+ {`
	`165`	`+ }`
	`166`	`+`
	`167`	`+ public PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind,`
	`168`	`+ float twist, float pressure, float xTilt, float yTilt, Rect contactRect) : this(modifiers, kind)`
`160`	`169`	`{`
`161`	`170`	`Twist = twist;`
`162`	`171`	`Pressure = pressure;`
`163`	`172`	`XTilt = xTilt;`
`164`	`173`	`YTilt = yTilt;`
	`174`	`+ ContactRect = contactRect;`
`165`	`175`	`}`
`166`	`176`
`167`	`177`	`internal PointerPointProperties(RawInputModifiers modifiers, PointerUpdateKind kind, RawPointerPoint rawPoint)`
`168`		`- : this(modifiers, kind, rawPoint.Twist, rawPoint.Pressure, rawPoint.XTilt, rawPoint.YTilt)`
	`178`	`+ : this(modifiers, kind, rawPoint.Twist, rawPoint.Pressure, rawPoint.XTilt, rawPoint.YTilt, rawPoint.ContactRect)`
`169`	`179`	`{`
`170`	`180`	`}`
`171`	`181`