x11: Implement precision/pixel scrolling

Manual rebase of libsdl-org#5382 with some changes for SDL3 (thanks @wooosh).

Author: Kontrabant

cmake/sdlchecks.cmake

@@ -416,6 +416,17 @@ macro(CheckX11)
         endif()
         set(SDL_VIDEO_DRIVER_X11_XINPUT2 1)
 
+        # Check for scroll info
+        check_c_source_compiles("
+            #include <X11/Xlib.h>
+            #include <X11/Xproto.h>
+            #include <X11/extensions/XInput2.h>
+            XIScrollClassInfo *s;
+            int main(int argc, char **argv) {}" HAVE_XINPUT2_SCROLLINFO)
+        if(HAVE_XINPUT2_SCROLLINFO)
+          set(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO 1)
+        endif()
+
         # Check for multitouch
         check_c_source_compiles_static("
             #include <X11/Xlib.h>

include/build_config/SDL_build_config.h.cmake

@@ -430,6 +430,7 @@
 #cmakedefine SDL_VIDEO_DRIVER_X11_XFIXES 1
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2 1
 #cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH 1
+#cmakedefine SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO 1
 #cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR 1
 #cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER 1
 #cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE 1

src/video/x11/SDL_x11events.c

@@ -1032,6 +1032,16 @@ void X11_HandleButtonPress(SDL_VideoDevice *_this, SDL_WindowData *windowdata, S
     }
 
     if (X11_IsWheelEvent(display, button, &xticks, &yticks)) {
+
+        /* If the system version of XInput2 supports precision scrolling, then
+         * it will perform 2 way emulation between the old button system and the
+         * new valuator system. handling both results in duplicate events, so if
+         * the system supports xinput, we ignore all wheel button events.
+        */
+        if (videodata->xinput_scrolling) {
+            return;
+        }
+
         SDL_SendMouseWheel(timestamp, window, mouseID, (float)-xticks, (float)yticks, SDL_MOUSEWHEEL_NORMAL);
     } else {
         bool ignore_click = false;

src/video/x11/SDL_x11video.c

@@ -468,6 +468,7 @@ void X11_VideoQuit(SDL_VideoDevice *_this)
     }
 #endif
 
+    X11_QuitXinput2(_this);
     X11_QuitModes(_this);
     X11_QuitKeyboard(_this);
     X11_QuitMouse(_this);

src/video/x11/SDL_x11video.h

@@ -139,6 +139,7 @@ struct SDL_VideoData
     SDL_XInput2DeviceInfo *mouse_device_info;
     int xinput_master_pointer_device;
     bool xinput_hierarchy_changed;
+    bool xinput_scrolling;
 
     int xrandr_event_base;
     struct

src/video/x11/SDL_x11window.c

@@ -475,7 +475,7 @@ static void SetupWindowInput(SDL_VideoDevice *_this, SDL_Window *window)
     }
 #endif
 
-    X11_Xinput2SelectTouch(_this, window);
+    X11_Xinput2Select(_this, window);
 
     {
         unsigned int x11_keyboard_events = KeyPressMask | KeyReleaseMask;

src/video/x11/SDL_x11xinput2.c

@@ -45,6 +45,20 @@ static bool xinput2_multitouch_supported;
  * this extension */
 static int xinput2_opcode;
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+typedef struct
+{
+    int device_id;
+    int axis_id[2]; // 0 = horizontal, 1 = vertical
+    double prev_coord[2];
+    bool prev_coord_valid[2];
+    double line_unit[2]; // Specifies the amount of coordinate change to scroll one line
+} SDL_XInput2ScrollableDevice;
+
+static SDL_XInput2ScrollableDevice *scrollable_devices;
+static int scrollable_device_count;
+#endif
+
 static void parse_valuators(const double *input_values, const unsigned char *mask, int mask_len,
                             double *output_values, int output_values_len)
 {
@@ -95,6 +109,56 @@ static SDL_Window *xinput2_get_sdlwindow(SDL_VideoData *videodata, Window window
     return windowdata ? windowdata->window : NULL;
 }
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+static void xinput2_reset_scrollable_devices(SDL_VideoData *videodata)
+{
+    for (int i = 0; i < scrollable_device_count; ++i) {
+        scrollable_devices[i].prev_coord_valid[0] = false;
+        scrollable_devices[i].prev_coord_valid[1] = false;
+    }
+}
+
+static void xinput2_parse_scrollable_valuators(const XIDeviceEvent *xev)
+{
+    SDL_Mouse *mouse = SDL_GetMouse();
+
+    for (int i = 0; i < scrollable_device_count; ++i) {
+        SDL_XInput2ScrollableDevice *sd = &scrollable_devices[i];
+        // Filter out events from the master device to avoid duplicates.
+        if (xev->sourceid == sd->device_id) {
+            int values_i = 0;
+            for (int j = 0; j < xev->valuators.mask_len * 8; ++j) {
+                if (!XIMaskIsSet(xev->valuators.mask, j)) {
+                    continue;
+                }
+
+                for (int k = 0; k < 2; ++k) {
+                    if (sd->axis_id[k] == j) {
+                        const double current_val = xev->valuators.values[values_i];
+                        const double delta = (sd->prev_coord[k] - current_val) / sd->line_unit[k];
+                        /* Ignore very large jumps that can happen as a result of overflowing
+                         * the maximum range, as the driver will reset the position to zero
+                         * at "something that's close to 2^32".
+                         *
+                         * http://who-t.blogspot.com/2012/06/xi-21-protocol-design-issues.html
+                         */
+                        if (sd->prev_coord_valid[k] && SDL_fabs(delta) < (double)SDL_MAX_UINT32 * 0.95) {
+                            const double x = k == 0 ? delta : 0;
+                            const double y = k == 1 ? delta : 0;
+                            SDL_SendMouseWheel(xev->time, mouse->focus, (SDL_MouseID)xev->sourceid, x, y, SDL_MOUSEWHEEL_NORMAL);
+                        }
+                        sd->prev_coord[k] = current_val;
+                        sd->prev_coord_valid[k] = true;
+                    }
+                }
+
+                ++values_i;
+            }
+        }
+    }
+}
+#endif // SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+
 #ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
 static void xinput2_normalize_touch_coordinates(SDL_Window *window, double in_x, double in_y, float *out_x, float *out_y)
 {
@@ -126,7 +190,7 @@ bool X11_InitXinput2(SDL_VideoDevice *_this)
 
     int version = 0;
     XIEventMask eventmask;
-    unsigned char mask[4] = { 0, 0, 0, 0 };
+    unsigned char mask[5] = { 0, 0, 0, 0, 0 };
     int event, err;
 
     /* XInput2 is required for relative mouse mode, so you probably want to leave this enabled */
@@ -156,6 +220,11 @@ bool X11_InitXinput2(SDL_VideoDevice *_this)
 
     xinput2_initialized = true;
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+    /* Xinput 2.1 is required to provide precision scrolling info */
+    data->xinput_scrolling = xinput2_version_atleast(version, 2, 1);
+#endif
+
 #ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH // Multitouch needs XInput 2.2
     xinput2_multitouch_supported = xinput2_version_atleast(version, 2, 2);
 #endif
@@ -171,6 +240,12 @@ bool X11_InitXinput2(SDL_VideoDevice *_this)
     XISetMask(mask, XI_RawButtonPress);
     XISetMask(mask, XI_RawButtonRelease);
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+    if (data->xinput_scrolling) {
+        XISetMask(mask, XI_Motion);
+    }
+#endif
+
 #ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
     // Enable raw touch events if supported
     if (X11_Xinput2IsMultitouchSupported()) {
@@ -199,6 +274,15 @@ bool X11_InitXinput2(SDL_VideoDevice *_this)
 #endif
 }
 
+void X11_QuitXinput2(SDL_VideoDevice *_this)
+{
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+    SDL_free(scrollable_devices);
+    scrollable_devices = NULL;
+    scrollable_device_count = 0;
+#endif
+}
+
 #ifdef SDL_VIDEO_DRIVER_X11_XINPUT2
 // xi2 device went away? take it out of the list.
 static void xinput2_remove_device_info(SDL_VideoData *videodata, const int device_id)
@@ -435,13 +519,19 @@ void X11_HandleXinput2Event(SDL_VideoDevice *_this, XGenericEventCookie *cookie)
         }
     } break;
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+    case XI_Enter:
+        xinput2_reset_scrollable_devices(videodata);
+        break;
+#endif
+
     /* Register to receive XI_Motion (which deactivates MotionNotify), so that we can distinguish
        real mouse motions from synthetic ones, for multitouch and pen support. */
     case XI_Motion:
     {
         const XIDeviceEvent *xev = (const XIDeviceEvent *)cookie->data;
-#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
-        bool pointer_emulated = ((xev->flags & XIPointerEmulated) != 0);
+#if defined(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO) || defined(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH)
+        bool pointer_emulated = (xev->flags & XIPointerEmulated) != 0;
 #else
         bool pointer_emulated = false;
 #endif
@@ -467,14 +557,23 @@ void X11_HandleXinput2Event(SDL_VideoDevice *_this, XGenericEventCookie *cookie)
                     SDL_SendPenAxis(0, pen->pen, window, (SDL_PenAxis) i, axes[i]);
                 }
             }
-        } else if (!pointer_emulated && xev->deviceid == videodata->xinput_master_pointer_device) {
-            // Use the master device for non-relative motion, as the slave devices can seemingly lag behind.
-            SDL_Mouse *mouse = SDL_GetMouse();
-            if (!mouse->relative_mode) {
-                SDL_Window *window = xinput2_get_sdlwindow(videodata, xev->event);
-                if (window) {
-                    X11_ProcessHitTest(_this, window->internal, (float)xev->event_x, (float)xev->event_y, false);
-                    SDL_SendMouseMotion(0, window, SDL_GLOBAL_MOUSE_ID, false, (float)xev->event_x, (float)xev->event_y);
+        } else {
+#if SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+            // Filter out events from the master device to avoid duplicates.
+            if (videodata->xinput_scrolling && xev->deviceid == xev->sourceid) {
+                xinput2_parse_scrollable_valuators(xev);
+            }
+#endif
+
+            if (!pointer_emulated && xev->deviceid == videodata->xinput_master_pointer_device) {
+                // Use the master device for non-relative motion, as the slave devices can seemingly lag behind.
+                SDL_Mouse *mouse = SDL_GetMouse();
+                if (!mouse->relative_mode) {
+                    SDL_Window *window = xinput2_get_sdlwindow(videodata, xev->event);
+                    if (window) {
+                        X11_ProcessHitTest(_this, window->internal, (float)xev->event_x, (float)xev->event_y, false);
+                        SDL_SendMouseMotion(0, window, SDL_GLOBAL_MOUSE_ID, false, (float)xev->event_x, (float)xev->event_y);
+                    }
                 }
             }
         }
@@ -516,29 +615,36 @@ void X11_InitXinput2Multitouch(SDL_VideoDevice *_this)
 {
 }
 
-void X11_Xinput2SelectTouch(SDL_VideoDevice *_this, SDL_Window *window)
+void X11_Xinput2Select(SDL_VideoDevice *_this, SDL_Window *window)
 {
-#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
-    SDL_VideoData *data = NULL;
+#if defined(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO) || defined(SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH)
+    SDL_VideoData *data = _this->internal;
+    SDL_WindowData *window_data = window->internal;
     XIEventMask eventmask;
-    unsigned char mask[4] = { 0, 0, 0, 0 };
-    SDL_WindowData *window_data = NULL;
+    unsigned char mask[5] = { 0, 0, 0, 0, 0 };
 
-    if (!X11_Xinput2IsMultitouchSupported()) {
+    if (!data->xinput_scrolling && !X11_Xinput2IsMultitouchSupported()) {
         return;
     }
 
-    data = _this->internal;
-    window_data = window->internal;
-
     eventmask.deviceid = XIAllMasterDevices;
     eventmask.mask_len = sizeof(mask);
     eventmask.mask = mask;
 
-    XISetMask(mask, XI_TouchBegin);
-    XISetMask(mask, XI_TouchUpdate);
-    XISetMask(mask, XI_TouchEnd);
-    XISetMask(mask, XI_Motion);
+    if (data->xinput_scrolling) {
+        /* Track enter events that inform us that we need to update
+         * the previous scroll coordinates since we cannot track
+         * them outside our window.
+         */
+        XISetMask(mask, XI_Enter);
+    }
+
+    if (X11_Xinput2IsMultitouchSupported()) {
+        XISetMask(mask, XI_TouchBegin);
+        XISetMask(mask, XI_TouchUpdate);
+        XISetMask(mask, XI_TouchEnd);
+        XISetMask(mask, XI_Motion);
+    }
 
     X11_XISelectEvents(data->display, window_data->xwindow, &eventmask, 1);
 #endif
@@ -740,6 +846,13 @@ void X11_Xinput2UpdateDevices(SDL_VideoDevice *_this, bool initial_check)
     old_mice = SDL_GetMice(&old_mouse_count);
     old_touch_devices = SDL_GetTouchDevices(&old_touch_count);
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+    // Scroll devices don't get add/remove events, so just rebuild the list.
+    SDL_free(scrollable_devices);
+    scrollable_devices = NULL;
+    scrollable_device_count = 0;
+#endif
+
     for (int i = 0; i < ndevices; i++) {
         XIDeviceInfo *dev = &info[i];
 
@@ -770,6 +883,38 @@ void X11_Xinput2UpdateDevices(SDL_VideoDevice *_this, bool initial_check)
             break;
         }
 
+#ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_SCROLLINFO
+        bool found_scrollable_device = false;
+        for (int j = 0; j < dev->num_classes; j++) {
+            const XIAnyClassInfo *class = dev->classes[j];
+            const XIScrollClassInfo *s = (XIScrollClassInfo *)class;
+
+            if (class->type != XIScrollClass) {
+                continue;
+            }
+
+            if (!found_scrollable_device) {
+                scrollable_devices = SDL_realloc(scrollable_devices, (scrollable_device_count + 1) * sizeof(SDL_XInput2ScrollableDevice));
+                if (!scrollable_devices) {
+                    // No memory, so just skip this
+                    break;
+                }
+            }
+
+            SDL_XInput2ScrollableDevice *sd = &scrollable_devices[scrollable_device_count];
+            const int dir = s->scroll_type == XIScrollTypeVertical;
+            sd->device_id = dev->deviceid;
+            sd->axis_id[dir] = s->number;
+            sd->line_unit[dir] = s->increment;
+
+            found_scrollable_device = true;
+        }
+
+        if (found_scrollable_device) {
+            ++scrollable_device_count;
+        }
+#endif
+
 #ifdef SDL_VIDEO_DRIVER_X11_XINPUT2_SUPPORTS_MULTITOUCH
         for (int j = 0; j < dev->num_classes; j++) {
             Uint64 touchID;

src/video/x11/SDL_x11xinput2.h

@@ -31,11 +31,12 @@ typedef struct XGenericEventCookie XGenericEventCookie;
 #endif
 
 extern bool X11_InitXinput2(SDL_VideoDevice *_this);
+extern void X11_QuitXinput2(SDL_VideoDevice *_this);
 extern void X11_InitXinput2Multitouch(SDL_VideoDevice *_this);
 extern void X11_HandleXinput2Event(SDL_VideoDevice *_this, XGenericEventCookie *cookie);
 extern bool X11_Xinput2IsInitialized(void);
 extern bool X11_Xinput2IsMultitouchSupported(void);
-extern void X11_Xinput2SelectTouch(SDL_VideoDevice *_this, SDL_Window *window);
+extern void X11_Xinput2Select(SDL_VideoDevice *_this, SDL_Window *window);
 extern void X11_Xinput2GrabTouch(SDL_VideoDevice *_this, SDL_Window *window);
 extern void X11_Xinput2UngrabTouch(SDL_VideoDevice *_this, SDL_Window *window);
 extern bool X11_Xinput2SelectMouseAndKeyboard(SDL_VideoDevice *_this, SDL_Window *window);