xcb: Use XCB instead of Xlib for XInput

- Replace xinput2 feature by xcb-xinput, which doesn't
  depend on xcb-xlib
- Remove xi2PrepareXIGenericDeviceEvent() that was used to
  fix incompatibilty between XCB and libXi structs
- Drop XCB_USE_XINPUT21 and XCB_USE_XINPUT22 defines that were
  needed with libXi

Although xcb-xinput was released in version 1.13 of libxcb,
it was quite stable in version 1.12, and the parts that we
use did not change between versions, so require system
xcb-xinput 1.12.

[ChangeLog][X11] The xcb plugin was ported to use libxcb-xinput
instead of libXi for XInput2 support. The -xinput2 configure
option was replaced by -xcb-xinput.

Task-number: QTBUG-39624
Change-Id: I37475b09b2bd7057763345c3f33d8c7751a4e831
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Gatis Paeglis <gatis.paeglis@qt.io>

9 files changed, 357 insertions, 427 deletions

diff --git a/src/plugins/platforms/xcb/README b/src/plugins/platforms/xcb/README
index 8308db46dc..2f5b55f5d1 100644
--- a/src/plugins/platforms/xcb/README
+++ b/src/plugins/platforms/xcb/README
@@ -3,7 +3,7 @@ Requires libxcb >= 1.5.
 PACKAGE DEPENDENCIES
 
 Required packages:
-libxcb1 libxcb1-dev libx11-xcb1 libx11-xcb-dev libxcb-keysyms1 libxcb-keysyms1-dev libxcb-image0 libxcb-image0-dev libxcb-shm0 libxcb-shm0-dev libxcb-icccm1 libxcb-icccm1-dev libxcb-sync0 libxcb-sync0-dev libxcb-render-util0 libxcb-render-util0-dev libxcb-xfixes0-dev libxrender-dev libxcb-shape0-dev libxcb-randr0-dev libxcb-glx0-dev libxcb-xinerama0-dev
+libxcb1 libxcb1-dev libx11-xcb1 libx11-xcb-dev libxcb-keysyms1 libxcb-keysyms1-dev libxcb-image0 libxcb-image0-dev libxcb-shm0 libxcb-shm0-dev libxcb-icccm1 libxcb-icccm1-dev libxcb-sync0 libxcb-sync0-dev libxcb-render-util0 libxcb-render-util0-dev libxcb-xfixes0-dev libxrender-dev libxcb-shape0-dev libxcb-randr0-dev libxcb-glx0-dev libxcb-xinerama0-dev libxcb-xinput0-dev
 
 On Ubuntu 11.10 icccm1 is replaced by icccm4 and xcb-render-util is not available:
 libxcb1 libxcb1-dev libx11-xcb1 libx11-xcb-dev libxcb-keysyms1 libxcb-keysyms1-dev libxcb-image0 libxcb-image0-dev libxcb-shm0 libxcb-shm0-dev libxcb-icccm4 libxcb-icccm4-dev libxcb-sync0 libxcb-sync0-dev libxcb-xfixes0-dev libxrender-dev libxcb-shape0-dev libxcb-randr0-dev libxcb-glx0-dev libxcb-xinerama0-dev
@@ -21,12 +21,3 @@ REDUCING RUNTIME DEPENDENCIES
 The '-qt-xcb' configure option can be used to get rid of most xcb- dependencies. Only libxcb will
 still be linked dynamically, since it will be most likely be pulled in via other dependencies anyway.
 This should allow for binaries that are portable across most modern Linux distributions.
-
-PACKAGE VERSION REQUIREMENTS
-
-When using touch input via XInput 2.2 or higher, there is a potential issue on systems that ship with
-a libXi older than 1.7.5. This is because XIAllowTouchEvents can deadlock with libXi 1.7.4 and earlier.
-When touch events are never received, this is not an issue, so plain mouse/keyboard systems are not affected.
-Qt versions before 5.8 attempted to recognize this scenario based on the pkg-config package version and skip
-the call. This has been removed starting from 5.8 since relying on pkg-config package versions is unsafe given
-that Qt must also support systems with limited or incomplete pkg-config setups.
diff --git a/src/plugins/platforms/xcb/qxcbconnection.cpp b/src/plugins/platforms/xcb/qxcbconnection.cpp
index 7d213320a4..ac0aade958 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@@ -76,8 +76,8 @@
 #include <X11/Xutil.h>
 #endif
 
-#if QT_CONFIG(xinput2)
-#include <X11/extensions/XI2proto.h>
+#if QT_CONFIG(xcb_xinput)
+#include <xcb/xinput.h>
 #endif
 
 #if QT_CONFIG(xcb_render)
@@ -120,7 +120,7 @@ Q_LOGGING_CATEGORY(lcQpaKeyboard, "qt.qpa.xkeyboard")
 #define XCB_GE_GENERIC 35
 #endif
 
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
 // Starting from the xcb version 1.9.3 struct xcb_ge_event_t has changed:
 // - "pad0" became "extension"
 // - "pad1" and "pad" became "pad0"
@@ -138,7 +138,7 @@ static inline bool isXIEvent(xcb_generic_event_t *event, int opCode)
     qt_xcb_ge_event_t *e = reinterpret_cast<qt_xcb_ge_event_t *>(event);
     return e->extension == opCode;
 }
-#endif // QT_CONFIG(xinput2)
+#endif // QT_CONFIG(xcb_xinput)
 
 #if QT_CONFIG(xcb_xlib)
 static const char * const xcbConnectionErrors[] = {
@@ -573,6 +573,9 @@ QXcbConnection::QXcbConnection(QXcbNativeInterface *nativeInterface, bool canGra
 #if QT_CONFIG(xcb_render)
         &xcb_render_id,
 #endif
+#if QT_CONFIG(xcb_xinput)
+        &xcb_input_id,
+#endif
         0
     };
 
@@ -592,7 +595,7 @@ QXcbConnection::QXcbConnection(QXcbNativeInterface *nativeInterface, bool canGra
     initializeScreens();
 
     initializeXRender();
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     if (!qEnvironmentVariableIsSet("QT_XCB_NO_XI2"))
         initializeXInput2();
 #endif
@@ -1105,13 +1108,13 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
             handleClientMessageEvent((xcb_client_message_event_t *)event);
             break;
         case XCB_ENTER_NOTIFY:
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
             if (hasXInput2() && !xi2MouseEventsDisabled())
                 break;
 #endif
             HANDLE_PLATFORM_WINDOW_EVENT(xcb_enter_notify_event_t, event, handleEnterNotifyEvent);
         case XCB_LEAVE_NOTIFY:
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
             if (hasXInput2() && !xi2MouseEventsDisabled())
                 break;
 #endif
@@ -1174,7 +1177,7 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
             }
             break;
         }
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
         case XCB_GE_GENERIC:
             // Here the windowEventListener is invoked from xi2HandleEvent()
             if (hasXInput2() && isXIEvent(event, m_xiOpCode))
@@ -1630,16 +1633,14 @@ void *QXcbConnection::createVisualInfoForDefaultVisualId() const
 
 #endif
 
-#if QT_CONFIG(xinput2)
-// it is safe to cast XI_* events here as long as we are only touching the first 32 bytes,
-// after that position event needs memmove, see xi2PrepareXIGenericDeviceEvent
+#if QT_CONFIG(xcb_xinput)
 static inline bool isXIType(xcb_generic_event_t *event, int opCode, uint16_t type)
 {
     if (!isXIEvent(event, opCode))
         return false;
 
-    xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
-    return xiEvent->evtype == type;
+    auto *e = reinterpret_cast<qt_xcb_ge_event_t *>(event);
+    return e->event_type == type;
 }
 #endif
 static inline bool isValid(xcb_generic_event_t *event)
@@ -1675,16 +1676,16 @@ bool QXcbConnection::compressEvent(xcb_generic_event_t *event, int currentIndex,
         }
         return false;
     }
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     // compress XI_* events
     if (responseType == XCB_GE_GENERIC) {
         if (!hasXInput2())
             return false;
 
         // compress XI_Motion, but not from tablet devices
-        if (isXIType(event, m_xiOpCode, XI_Motion)) {
+        if (isXIType(event, m_xiOpCode, XCB_INPUT_MOTION)) {
 #if QT_CONFIG(tabletevent)
-            xXIDeviceEvent *xdev = reinterpret_cast<xXIDeviceEvent *>(event);
+            auto *xdev = reinterpret_cast<xcb_input_motion_event_t *>(event);
             if (!QCoreApplication::testAttribute(Qt::AA_CompressTabletEvents) &&
                     const_cast<QXcbConnection *>(this)->tabletDataForDevice(xdev->sourceid))
                 return false;
@@ -1693,29 +1694,27 @@ bool QXcbConnection::compressEvent(xcb_generic_event_t *event, int currentIndex,
                 xcb_generic_event_t *next = eventqueue->at(j);
                 if (!isValid(next))
                     continue;
-                if (isXIType(next, m_xiOpCode, XI_Motion))
+                if (isXIType(next, m_xiOpCode, XCB_INPUT_MOTION))
                     return true;
             }
             return false;
         }
-#ifdef XCB_USE_XINPUT22
         // compress XI_TouchUpdate for the same touch point id
-        if (isXIType(event, m_xiOpCode, XI_TouchUpdate)) {
-            xXIDeviceEvent *xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
-            uint32_t id = xiDeviceEvent->detail % INT_MAX;
+        if (isXIType(event, m_xiOpCode, XCB_INPUT_TOUCH_UPDATE)) {
+            auto *touchUpdateEvent = reinterpret_cast<xcb_input_touch_update_event_t *>(event);
+            uint32_t id = touchUpdateEvent->detail % INT_MAX;
             for (int j = nextIndex; j < eventqueue->size(); ++j) {
                 xcb_generic_event_t *next = eventqueue->at(j);
                 if (!isValid(next))
                     continue;
-                if (isXIType(next, m_xiOpCode, XI_TouchUpdate)) {
-                    xXIDeviceEvent *xiDeviceNextEvent = reinterpret_cast<xXIDeviceEvent *>(next);
-                    if (id == xiDeviceNextEvent->detail % INT_MAX)
+                if (isXIType(next, m_xiOpCode, XCB_INPUT_TOUCH_UPDATE)) {
+                    auto *touchUpdateNextEvent = reinterpret_cast<xcb_input_touch_update_event_t *>(next);
+                    if (id == touchUpdateNextEvent->detail % INT_MAX)
                         return true;
                 }
             }
             return false;
         }
-#endif
         return false;
     }
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbconnection.h b/src/plugins/platforms/xcb/qxcbconnection.h
index 4a9958f334..c8b5c5095c 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.h
+++ b/src/plugins/platforms/xcb/qxcbconnection.h
@@ -71,16 +71,6 @@
 #include <QTabletEvent>
 #endif
 
-#if QT_CONFIG(xinput2)
-#include <X11/extensions/XI2.h>
-#ifdef XIScrollClass
-#define XCB_USE_XINPUT21    // XI 2.1 adds smooth scrolling support
-#ifdef XI_TouchBeginMask
-#define XCB_USE_XINPUT22    // XI 2.2 adds multi-point touch support
-#endif
-#endif
-#endif // QT_CONFIG(xinput2)
-
 struct xcb_randr_get_output_info_reply_t;
 
 QT_BEGIN_NAMESPACE
@@ -359,7 +349,7 @@ public:
     virtual void handleFocusInEvent(const xcb_focus_in_event_t *) {}
     virtual void handleFocusOutEvent(const xcb_focus_out_event_t *) {}
     virtual void handlePropertyNotifyEvent(const xcb_property_notify_event_t *) {}
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     virtual void handleXIMouseEvent(xcb_ge_event_t *, Qt::MouseEventSource = Qt::MouseEventNotSynthesized) {}
     virtual void handleXIEnterLeave(xcb_ge_event_t *) {}
 #endif
@@ -511,7 +501,7 @@ public:
     static bool xEmbedSystemTrayAvailable();
     static bool xEmbedSystemTrayVisualHasAlphaChannel();
 
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     void xi2SelectStateEvents();
     void xi2SelectDeviceEvents(xcb_window_t window);
     void xi2SelectDeviceEventsCompatibility(xcb_window_t window);
@@ -520,14 +510,10 @@ public:
     bool isAtLeastXI21() const { return m_xi2Enabled && m_xi2Minor >= 1; }
     bool isAtLeastXI22() const { return m_xi2Enabled && m_xi2Minor >= 2; }
     Qt::MouseButton xiToQtMouseButton(uint32_t b);
-#ifdef XCB_USE_XINPUT21
     void xi2UpdateScrollingDevices();
-#endif
-#ifdef XCB_USE_XINPUT22
     bool startSystemMoveResizeForTouchBegin(xcb_window_t window, const QPoint &point, int corner);
     bool isTouchScreen(int id);
 #endif
-#endif
     QXcbEventReader *eventReader() const { return m_reader; }
 
     bool canGrab() const { return m_canGrabServer; }
@@ -568,7 +554,7 @@ private:
     bool compressEvent(xcb_generic_event_t *event, int currentIndex, QXcbEventArray *eventqueue) const;
 
     bool m_xi2Enabled = false;
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     int m_xi2Minor = -1;
     void initializeXInput2();
     void xi2SetupDevice(void *info, bool removeExisting = true);
@@ -596,10 +582,8 @@ private:
     void xi2HandleEvent(xcb_ge_event_t *event);
     void xi2HandleHierarchyEvent(void *event);
     void xi2HandleDeviceChangedEvent(void *event);
-    int m_xiOpCode, m_xiEventBase, m_xiErrorBase;
-#ifdef XCB_USE_XINPUT22
+    int m_xiOpCode;
     void xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindow);
-#endif // XCB_USE_XINPUT22
 #if QT_CONFIG(tabletevent)
     struct TabletData {
         int deviceId = 0;
@@ -634,14 +618,11 @@ private:
         QPointF lastScrollPosition;
     };
     QHash<int, ScrollingDevice> m_scrollingDevices;
-#ifdef XCB_USE_XINPUT21
     void xi2HandleScrollEvent(void *event, ScrollingDevice &scrollingDevice);
     void xi2UpdateScrollingDevice(ScrollingDevice &scrollingDevice);
     ScrollingDevice *scrollingDeviceForId(int id);
-#endif
 
     static bool xi2GetValuatorValueIfSet(const void *event, int valuatorNum, double *value);
-    static void xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event);
 #endif
 
     xcb_connection_t *m_connection = nullptr;
@@ -675,9 +656,8 @@ private:
 #endif
     QXcbEventReader *m_reader = nullptr;
 
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     QHash<int, TouchDeviceData> m_touchDevices;
-#ifdef XCB_USE_XINPUT22
     struct StartSystemMoveResizeInfo {
         xcb_window_t window = XCB_NONE;
         uint16_t deviceid;
@@ -685,7 +665,6 @@ private:
         int corner;
     } m_startSystemMoveResizeInfo;
 #endif
-#endif
     WindowMapper m_mapper;
 
     QVector<PeekFunc> m_peekFuncs;
@@ -693,6 +672,9 @@ private:
     uint32_t xfixes_first_event = 0;
     uint32_t xrandr_first_event = 0;
     uint32_t xkb_first_event = 0;
+#if QT_CONFIG(xcb_xinput)
+    uint32_t xinput_first_event = 0;
+#endif
 
     bool has_xfixes = false;
     bool has_xinerama_extension = false;
@@ -726,7 +708,7 @@ private:
     QHash<qint32, qint32> m_peekerToCachedIndex;
     friend class QXcbEventReader;
 };
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
 #if QT_CONFIG(tabletevent)
 Q_DECLARE_TYPEINFO(QXcbConnection::TabletData::ValuatorClassInfo, Q_PRIMITIVE_TYPE);
 Q_DECLARE_TYPEINFO(QXcbConnection::TabletData, Q_MOVABLE_TYPE);
diff --git a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
index 0302d585b5..475afa65db 100644
--- a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
@@ -47,59 +47,51 @@
 #include <QDebug>
 #include <cmath>
 
-#include <X11/extensions/XInput2.h>
-#include <X11/extensions/XI2proto.h>
+#include <xcb/xinput.h>
+
+using qt_xcb_input_device_event_t = xcb_input_button_press_event_t;
 
 void QXcbConnection::initializeXInput2()
 {
-    Display *xDisplay = static_cast<Display *>(m_xlib_display);
-    if (XQueryExtension(xDisplay, "XInputExtension", &m_xiOpCode, &m_xiEventBase, &m_xiErrorBase)) {
-        int xiMajor = 2;
-#if defined(XCB_USE_XINPUT22)
-        m_xi2Minor = 2; // for touch support 2.2 is enough
-#elif defined(XCB_USE_XINPUT21)
-        m_xi2Minor = 1; // for smooth scrolling 2.1 is enough
-#else
-        m_xi2Minor = 0; // for tablet support 2.0 is enough
-#endif
-        qCDebug(lcQpaXInput, "Plugin build with support for XInput 2 version up "
-                             "to %d.%d", xiMajor, m_xi2Minor);
-
-        switch (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor)) {
-        case Success:
-            // Server's supported version can be lower than the version we have
-            // announced to support. In this case Qt client will be limited by
-            // X server's supported version.
-            qCDebug(lcQpaXInput, "Using XInput version %d.%d", xiMajor, m_xi2Minor);
-            m_xi2Enabled = true;
-            xi2SetupDevices();
-            xi2SelectStateEvents();
-            break;
-        case BadRequest: // Must be an X server with XInput 1
-            qCDebug(lcQpaXInput, "X server does not support XInput 2");
-            break;
-        default: // BadValue
-            qCDebug(lcQpaXInput, "Internal error");
-            break;
-        }
+    const xcb_query_extension_reply_t *reply = xcb_get_extension_data(m_connection, &xcb_input_id);
+    if (!reply || !reply->present) {
+        qCDebug(lcQpaXInput, "XInput extension is not present on the X server");
+        return;
+    }
+
+    m_xiOpCode = reply->major_opcode;
+    xinput_first_event = reply->first_event;
+
+    auto xinput_query = Q_XCB_REPLY(xcb_input_xi_query_version, m_connection, 2, 2);
+
+    if (!xinput_query || xinput_query->major_version != 2) {
+        qCWarning(lcQpaXInput, "X server does not support XInput 2");
+    } else {
+        qCDebug(lcQpaXInput, "Using XInput version %d.%d",
+                xinput_query->major_version, xinput_query->minor_version);
+        m_xi2Minor = xinput_query->minor_version;
+        m_xi2Enabled = true;
+        xi2SetupDevices();
+        xi2SelectStateEvents();
     }
 }
 
+struct qt_xcb_input_event_mask_t {
+    xcb_input_event_mask_t header;
+    uint32_t               mask;
+};
+
 void QXcbConnection::xi2SelectStateEvents()
 {
     // These state events do not depend on a specific X window, but are global
     // for the X client's (application's) state.
-    unsigned int bitMask = 0;
-    unsigned char *xiBitMask = reinterpret_cast<unsigned char *>(&bitMask);
-    XIEventMask xiEventMask;
-    bitMask = XI_HierarchyChangedMask;
-    bitMask |= XI_DeviceChangedMask;
-    bitMask |= XI_PropertyEventMask;
-    xiEventMask.deviceid = XIAllDevices;
-    xiEventMask.mask_len = sizeof(bitMask);
-    xiEventMask.mask = xiBitMask;
-    Display *dpy = static_cast<Display *>(m_xlib_display);
-    XISelectEvents(dpy, DefaultRootWindow(dpy), &xiEventMask, 1);
+    qt_xcb_input_event_mask_t xiEventMask;
+    xiEventMask.header.deviceid = XCB_INPUT_DEVICE_ALL;
+    xiEventMask.header.mask_len = 1;
+    xiEventMask.mask = XCB_INPUT_XI_EVENT_MASK_HIERARCHY;
+    xiEventMask.mask |= XCB_INPUT_XI_EVENT_MASK_DEVICE_CHANGED;
+    xiEventMask.mask |= XCB_INPUT_XI_EVENT_MASK_PROPERTY;
+    xcb_input_xi_select_events(m_connection, rootWindow(), 1, &xiEventMask.header);
 }
 
 void QXcbConnection::xi2SelectDeviceEvents(xcb_window_t window)
@@ -107,38 +99,42 @@ void QXcbConnection::xi2SelectDeviceEvents(xcb_window_t window)
     if (window == rootWindow())
         return;
 
-    unsigned int bitMask = 0;
-    unsigned char *xiBitMask = reinterpret_cast<unsigned char *>(&bitMask);
-    bitMask |= XI_ButtonPressMask;
-    bitMask |= XI_ButtonReleaseMask;
-    bitMask |= XI_MotionMask;
+    uint32_t bitMask = XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS;
+    bitMask |= XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE;
+    bitMask |= XCB_INPUT_XI_EVENT_MASK_MOTION;
     // There is a check for enter/leave events in plain xcb enter/leave event handler,
     // core enter/leave events will be ignored in this case.
-    bitMask |= XI_EnterMask;
-    bitMask |= XI_LeaveMask;
-#ifdef XCB_USE_XINPUT22
+    bitMask |= XCB_INPUT_XI_EVENT_MASK_ENTER;
+    bitMask |= XCB_INPUT_XI_EVENT_MASK_LEAVE;
     if (isAtLeastXI22()) {
-        bitMask |= XI_TouchBeginMask;
-        bitMask |= XI_TouchUpdateMask;
-        bitMask |= XI_TouchEndMask;
+        bitMask |= XCB_INPUT_XI_EVENT_MASK_TOUCH_BEGIN;
+        bitMask |= XCB_INPUT_XI_EVENT_MASK_TOUCH_UPDATE;
+        bitMask |= XCB_INPUT_XI_EVENT_MASK_TOUCH_END;
     }
-#endif
 
-    XIEventMask mask;
-    mask.mask_len = sizeof(bitMask);
-    mask.mask = xiBitMask;
-    mask.deviceid = XIAllMasterDevices;
-    Display *dpy = static_cast<Display *>(m_xlib_display);
-    Status result = XISelectEvents(dpy, window, &mask, 1);
-    if (result == Success)
+    qt_xcb_input_event_mask_t mask;
+    mask.header.deviceid = XCB_INPUT_DEVICE_ALL_MASTER;
+    mask.header.mask_len = 1;
+    mask.mask = bitMask;
+    xcb_void_cookie_t cookie =
+            xcb_input_xi_select_events_checked(m_connection, window, 1, &mask.header);
+    xcb_generic_error_t *error = xcb_request_check(m_connection, cookie);
+    if (error) {
+        qCDebug(lcQpaXInput, "failed to select events, window %x, error code %d", window, error->error_code);
+        free(error);
+    } else {
         QWindowSystemInterfacePrivate::TabletEvent::setPlatformSynthesizesMouse(false);
-    else
-        qCDebug(lcQpaXInput, "failed to select events, window %x, result %d", window, result);
+    }
+}
+
+static inline qreal fixed3232ToReal(xcb_input_fp3232_t val)
+{
+    return qreal(val.integral) + qreal(val.frac) / (1ULL << 32);
 }
 
 void QXcbConnection::xi2SetupDevice(void *info, bool removeExisting)
 {
-    XIDeviceInfo *deviceInfo = reinterpret_cast<XIDeviceInfo *>(info);
+    auto *deviceInfo = reinterpret_cast<xcb_input_xi_device_info_t *>(info);
     if (removeExisting) {
 #if QT_CONFIG(tabletevent)
         for (int i = 0; i < m_tabletData.count(); ++i) {
@@ -152,53 +148,54 @@ void QXcbConnection::xi2SetupDevice(void *info, bool removeExisting)
         m_touchDevices.remove(deviceInfo->deviceid);
     }
 
-    qCDebug(lcQpaXInputDevices) << "input device " << deviceInfo->name << "ID" << deviceInfo->deviceid;
+    qCDebug(lcQpaXInputDevices) << "input device " << xcb_input_xi_device_info_name(deviceInfo) << "ID" << deviceInfo->deviceid;
 #if QT_CONFIG(tabletevent)
     TabletData tabletData;
 #endif
     ScrollingDevice scrollingDevice;
-    for (int c = 0; c < deviceInfo->num_classes; ++c) {
-        XIAnyClassInfo *classinfo = deviceInfo->classes[c];
+    auto classes_it = xcb_input_xi_device_info_classes_iterator(deviceInfo);
+    for (; classes_it.rem; xcb_input_device_class_next(&classes_it)) {
+        xcb_input_device_class_t *classinfo = classes_it.data;
         switch (classinfo->type) {
-        case XIValuatorClass: {
-            XIValuatorClassInfo *vci = reinterpret_cast<XIValuatorClassInfo *>(classinfo);
+        case XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR: {
+            auto *vci = reinterpret_cast<xcb_input_valuator_class_t *>(classinfo);
             const int valuatorAtom = qatom(vci->label);
             qCDebug(lcQpaXInputDevices) << "   has valuator" << atomName(vci->label) << "recognized?" << (valuatorAtom < QXcbAtom::NAtoms);
 #if QT_CONFIG(tabletevent)
             if (valuatorAtom < QXcbAtom::NAtoms) {
                 TabletData::ValuatorClassInfo info;
-                info.minVal = vci->min;
-                info.maxVal = vci->max;
+                info.minVal = fixed3232ToReal(vci->min);
+                info.maxVal = fixed3232ToReal(vci->max);
                 info.number = vci->number;
                 tabletData.valuatorInfo[valuatorAtom] = info;
             }
 #endif // QT_CONFIG(tabletevent)
             if (valuatorAtom == QXcbAtom::RelHorizScroll || valuatorAtom == QXcbAtom::RelHorizWheel)
-                scrollingDevice.lastScrollPosition.setX(vci->value);
+                scrollingDevice.lastScrollPosition.setX(fixed3232ToReal(vci->value));
             else if (valuatorAtom == QXcbAtom::RelVertScroll || valuatorAtom == QXcbAtom::RelVertWheel)
-                scrollingDevice.lastScrollPosition.setY(vci->value);
+                scrollingDevice.lastScrollPosition.setY(fixed3232ToReal(vci->value));
             break;
         }
-#ifdef XCB_USE_XINPUT21
-        case XIScrollClass: {
-            XIScrollClassInfo *sci = reinterpret_cast<XIScrollClassInfo *>(classinfo);
-            if (sci->scroll_type == XIScrollTypeVertical) {
+        case XCB_INPUT_DEVICE_CLASS_TYPE_SCROLL: {
+            auto *sci = reinterpret_cast<xcb_input_scroll_class_t *>(classinfo);
+            if (sci->scroll_type == XCB_INPUT_SCROLL_TYPE_VERTICAL) {
                 scrollingDevice.orientations |= Qt::Vertical;
                 scrollingDevice.verticalIndex = sci->number;
-                scrollingDevice.verticalIncrement = sci->increment;
-            }
-            else if (sci->scroll_type == XIScrollTypeHorizontal) {
+                scrollingDevice.verticalIncrement = fixed3232ToReal(sci->increment);
+            } else if (sci->scroll_type == XCB_INPUT_SCROLL_TYPE_HORIZONTAL) {
                 scrollingDevice.orientations |= Qt::Horizontal;
                 scrollingDevice.horizontalIndex = sci->number;
-                scrollingDevice.horizontalIncrement = sci->increment;
+                scrollingDevice.horizontalIncrement = fixed3232ToReal(sci->increment);
             }
             break;
         }
-        case XIButtonClass: {
-            XIButtonClassInfo *bci = reinterpret_cast<XIButtonClassInfo *>(classinfo);
+        case XCB_INPUT_DEVICE_CLASS_TYPE_BUTTON: {
+            auto *bci = reinterpret_cast<xcb_input_button_class_t *>(classinfo);
+            xcb_atom_t *labels = 0;
             if (bci->num_buttons >= 5) {
-                Atom label4 = bci->labels[3];
-                Atom label5 = bci->labels[4];
+                labels = xcb_input_button_class_labels(bci);
+                xcb_atom_t label4 = labels[3];
+                xcb_atom_t label5 = labels[4];
                 // Some drivers have no labels on the wheel buttons, some have no label on just one and some have no label on
                 // button 4 and the wrong one on button 5. So we just check that they are not labelled with unrelated buttons.
                 if ((!label4 || qatom(label4) == QXcbAtom::ButtonWheelUp || qatom(label4) == QXcbAtom::ButtonWheelDown) &&
@@ -206,23 +203,20 @@ void QXcbConnection::xi2SetupDevice(void *info, bool removeExisting)
                     scrollingDevice.legacyOrientations |= Qt::Vertical;
             }
             if (bci->num_buttons >= 7) {
-                Atom label6 = bci->labels[5];
-                Atom label7 = bci->labels[6];
+                xcb_atom_t label6 = labels[5];
+                xcb_atom_t label7 = labels[6];
                 if ((!label6 || qatom(label6) == QXcbAtom::ButtonHorizWheelLeft) && (!label7 || qatom(label7) == QXcbAtom::ButtonHorizWheelRight))
                     scrollingDevice.legacyOrientations |= Qt::Horizontal;
             }
             qCDebug(lcQpaXInputDevices, "   has %d buttons", bci->num_buttons);
             break;
         }
-#endif
-        case XIKeyClass:
+        case XCB_INPUT_DEVICE_CLASS_TYPE_KEY:
             qCDebug(lcQpaXInputDevices) << "   it's a keyboard";
             break;
-#ifdef XCB_USE_XINPUT22
-        case XITouchClass:
+        case XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH:
             // will be handled in populateTouchDevices()
             break;
-#endif
         default:
             qCDebug(lcQpaXInputDevices) << "   has class" << classinfo->type;
             break;
@@ -237,7 +231,8 @@ void QXcbConnection::xi2SetupDevice(void *info, bool removeExisting)
         isTablet = true;
 
     // But we need to be careful not to take the touch and tablet-button devices as tablets.
-    QByteArray name = QByteArray(deviceInfo->name).toLower();
+    QByteArray name = QByteArray(xcb_input_xi_device_info_name(deviceInfo),
+                                 xcb_input_xi_device_info_name_length(deviceInfo)).toLower();
     QString dbgType = QLatin1String("UNKNOWN");
     if (name.contains("eraser")) {
         isTablet = true;
@@ -281,7 +276,6 @@ void QXcbConnection::xi2SetupDevice(void *info, bool removeExisting)
     }
 #endif // QT_CONFIG(tabletevent)
 
-#ifdef XCB_USE_XINPUT21
     if (scrollingDevice.orientations || scrollingDevice.legacyOrientations) {
         scrollingDevice.deviceId = deviceInfo->deviceid;
         // Only use legacy wheel button events when we don't have real scroll valuators.
@@ -289,7 +283,6 @@ void QXcbConnection::xi2SetupDevice(void *info, bool removeExisting)
         m_scrollingDevices.insert(scrollingDevice.deviceId, scrollingDevice);
         qCDebug(lcQpaXInputDevices) << "   it's a scrolling device";
     }
-#endif
 
     if (!isTablet) {
         TouchDeviceData *dev = populateTouchDevices(deviceInfo);
@@ -315,23 +308,28 @@ void QXcbConnection::xi2SetupDevices()
 #endif
     m_scrollingDevices.clear();
     m_touchDevices.clear();
-
-    Display *xDisplay = static_cast<Display *>(m_xlib_display);
-    int deviceCount = 0;
-    XIDeviceInfo *devices = XIQueryDevice(xDisplay, XIAllDevices, &deviceCount);
     m_xiMasterPointerIds.clear();
-    for (int i = 0; i < deviceCount; ++i) {
-        XIDeviceInfo deviceInfo = devices[i];
-        if (deviceInfo.use == XIMasterPointer) {
-            m_xiMasterPointerIds.append(deviceInfo.deviceid);
+
+    auto reply = Q_XCB_REPLY(xcb_input_xi_query_device, m_connection, XCB_INPUT_DEVICE_ALL);
+    if (!reply) {
+        qCDebug(lcQpaXInputDevices) << "failed to query devices";
+        return;
+    }
+
+    auto it = xcb_input_xi_query_device_infos_iterator(reply.get());
+    for (; it.rem; xcb_input_xi_device_info_next(&it)) {
+        xcb_input_xi_device_info_t *deviceInfo = it.data;
+        if (deviceInfo->type == XCB_INPUT_DEVICE_TYPE_MASTER_POINTER) {
+            m_xiMasterPointerIds.append(deviceInfo->deviceid);
             continue;
         }
-        if (deviceInfo.use == XISlavePointer) // only slave pointer devices are relevant here
-            xi2SetupDevice(&deviceInfo, false);
+        // only slave pointer devices are relevant here
+        if (deviceInfo->type == XCB_INPUT_DEVICE_TYPE_SLAVE_POINTER)
+            xi2SetupDevice(deviceInfo, false);
     }
+
     if (m_xiMasterPointerIds.size() > 1)
         qCDebug(lcQpaXInputDevices) << "multi-pointer X detected";
-    XIFreeDeviceInfo(devices);
 }
 
 /*! \internal
@@ -376,70 +374,64 @@ void QXcbConnection::xi2SelectDeviceEventsCompatibility(xcb_window_t window)
     if (window == rootWindow())
         return;
 
-    unsigned int mask = 0;
-    unsigned char *bitMask = reinterpret_cast<unsigned char *>(&mask);
-    Display *dpy = static_cast<Display *>(m_xlib_display);
+    uint32_t mask = 0;
 
-#ifdef XCB_USE_XINPUT22
     if (isAtLeastXI22()) {
-        mask |= XI_TouchBeginMask;
-        mask |= XI_TouchUpdateMask;
-        mask |= XI_TouchEndMask;
-
-        XIEventMask xiMask;
-        xiMask.mask_len = sizeof(mask);
-        xiMask.mask = bitMask;
-        xiMask.deviceid = XIAllMasterDevices;
-        Status result = XISelectEvents(dpy, window, &xiMask, 1);
-        if (result == Success)
+        mask |= XCB_INPUT_XI_EVENT_MASK_TOUCH_BEGIN;
+        mask |= XCB_INPUT_XI_EVENT_MASK_TOUCH_UPDATE;
+        mask |= XCB_INPUT_XI_EVENT_MASK_TOUCH_END;
+
+        qt_xcb_input_event_mask_t xiMask;
+        xiMask.header.deviceid = XCB_INPUT_DEVICE_ALL_MASTER;
+        xiMask.header.mask_len = 1;
+        xiMask.mask = mask;
+
+        xcb_void_cookie_t cookie =
+                xcb_input_xi_select_events_checked(m_connection, window, 1, &xiMask.header);
+        xcb_generic_error_t *error = xcb_request_check(m_connection, cookie);
+        if (error) {
+            qCDebug(lcQpaXInput, "failed to select events, window %x, error code %d", window, error->error_code);
+            free(error);
+        } else {
             QWindowSystemInterfacePrivate::TabletEvent::setPlatformSynthesizesMouse(false);
-        else
-            qCDebug(lcQpaXInput, "failed to select events, window %x, result %d", window, result);
+        }
     }
-#endif
 
-    mask = XI_ButtonPressMask;
-    mask |= XI_ButtonReleaseMask;
-    mask |= XI_MotionMask;
+    mask = XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS;
+    mask |= XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE;
+    mask |= XCB_INPUT_XI_EVENT_MASK_MOTION;
 
 #if QT_CONFIG(tabletevent)
     QSet<int> tabletDevices;
     if (!m_tabletData.isEmpty()) {
         const int nrTablets = m_tabletData.count();
-        QVector<XIEventMask> xiEventMask(nrTablets);
+        QVector<qt_xcb_input_event_mask_t> xiEventMask(nrTablets);
         for (int i = 0; i < nrTablets; ++i) {
             int deviceId = m_tabletData.at(i).deviceId;
             tabletDevices.insert(deviceId);
-            xiEventMask[i].deviceid = deviceId;
-            xiEventMask[i].mask_len = sizeof(mask);
-            xiEventMask[i].mask = bitMask;
+            xiEventMask[i].header.deviceid = deviceId;
+            xiEventMask[i].header.mask_len = 1;
+            xiEventMask[i].mask = mask;
         }
-        XISelectEvents(dpy, window, xiEventMask.data(), nrTablets);
+        xcb_input_xi_select_events(m_connection, window, nrTablets, &(xiEventMask.data()->header));
     }
 #endif
 
-#ifdef XCB_USE_XINPUT21
     if (!m_scrollingDevices.isEmpty()) {
-        QVector<XIEventMask> xiEventMask(m_scrollingDevices.size());
+        QVector<qt_xcb_input_event_mask_t> xiEventMask(m_scrollingDevices.size());
         int i = 0;
         for (const ScrollingDevice& scrollingDevice : qAsConst(m_scrollingDevices)) {
 #if QT_CONFIG(tabletevent)
             if (tabletDevices.contains(scrollingDevice.deviceId))
                 continue; // All necessary events are already captured.
 #endif
-            xiEventMask[i].deviceid = scrollingDevice.deviceId;
-            xiEventMask[i].mask_len = sizeof(mask);
-            xiEventMask[i].mask = bitMask;
+            xiEventMask[i].header.deviceid = scrollingDevice.deviceId;
+            xiEventMask[i].header.mask_len = 1;
+            xiEventMask[i].mask = mask;
             i++;
         }
-        XISelectEvents(dpy, window, xiEventMask.data(), i);
+        xcb_input_xi_select_events(m_connection, window, i, &(xiEventMask.data()->header));
     }
-#endif
-
-#if !QT_CONFIG(tabletevent) && !defined(XCB_USE_XINPUT21)
-    Q_UNUSED(bitMask);
-    Q_UNUSED(dpy);
-#endif
 }
 
 QXcbConnection::TouchDeviceData *QXcbConnection::touchDeviceForId(int id)
@@ -452,39 +444,38 @@ QXcbConnection::TouchDeviceData *QXcbConnection::touchDeviceForId(int id)
 
 QXcbConnection::TouchDeviceData *QXcbConnection::populateTouchDevices(void *info)
 {
-    XIDeviceInfo *deviceinfo = reinterpret_cast<XIDeviceInfo *>(info);
+    auto *deviceinfo = reinterpret_cast<xcb_input_xi_device_info_t *>(info);
     QTouchDevice::Capabilities caps = 0;
     int type = -1;
     int maxTouchPoints = 1;
     bool isTouchDevice = false;
     bool hasRelativeCoords = false;
     TouchDeviceData dev;
-    for (int i = 0; i < deviceinfo->num_classes; ++i) {
-        XIAnyClassInfo *classinfo = deviceinfo->classes[i];
+    auto classes_it = xcb_input_xi_device_info_classes_iterator(deviceinfo);
+    for (; classes_it.rem; xcb_input_device_class_next(&classes_it)) {
+        xcb_input_device_class_t *classinfo = classes_it.data;
         switch (classinfo->type) {
-#ifdef XCB_USE_XINPUT22
-        case XITouchClass: {
-            XITouchClassInfo *tci = reinterpret_cast<XITouchClassInfo *>(classinfo);
+        case XCB_INPUT_DEVICE_CLASS_TYPE_TOUCH: {
+            auto *tci = reinterpret_cast<xcb_input_touch_class_t *>(classinfo);
             maxTouchPoints = tci->num_touches;
             qCDebug(lcQpaXInputDevices, "   has touch class with mode %d", tci->mode);
             switch (tci->mode) {
-            case XIDependentTouch:
+            case XCB_INPUT_TOUCH_MODE_DEPENDENT:
                 type = QTouchDevice::TouchPad;
                 break;
-            case XIDirectTouch:
+            case XCB_INPUT_TOUCH_MODE_DIRECT:
                 type = QTouchDevice::TouchScreen;
                 break;
             }
             break;
         }
-#endif // XCB_USE_XINPUT22
-        case XIValuatorClass: {
-            XIValuatorClassInfo *vci = reinterpret_cast<XIValuatorClassInfo *>(classinfo);
+        case XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR: {
+            auto *vci = reinterpret_cast<xcb_input_valuator_class_t *>(classinfo);
             const QXcbAtom::Atom valuatorAtom = qatom(vci->label);
             if (valuatorAtom < QXcbAtom::NAtoms) {
                 TouchDeviceData::ValuatorClassInfo info;
-                info.min = vci->min;
-                info.max = vci->max;
+                info.min = fixed3232ToReal(vci->min);
+                info.max = fixed3232ToReal(vci->max);
                 info.number = vci->number;
                 info.label = valuatorAtom;
                 dev.valuatorInfo.append(info);
@@ -502,16 +493,16 @@ QXcbConnection::TouchDeviceData *QXcbConnection::populateTouchDevices(void *info
                 caps |= QTouchDevice::Pressure;
             else if (valuatorAtom == QXcbAtom::RelX) {
                 hasRelativeCoords = true;
-                dev.size.setWidth((vci->max - vci->min) * 1000.0 / vciResolution);
+                dev.size.setWidth((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
             } else if (valuatorAtom == QXcbAtom::RelY) {
                 hasRelativeCoords = true;
-                dev.size.setHeight((vci->max - vci->min) * 1000.0 / vciResolution);
+                dev.size.setHeight((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
             } else if (valuatorAtom == QXcbAtom::AbsX) {
                 caps |= QTouchDevice::Position;
-                dev.size.setWidth((vci->max - vci->min) * 1000.0 / vciResolution);
+                dev.size.setWidth((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
             } else if (valuatorAtom == QXcbAtom::AbsY) {
                 caps |= QTouchDevice::Position;
-                dev.size.setHeight((vci->max - vci->min) * 1000.0 / vciResolution);
+                dev.size.setHeight((fixed3232ToReal(vci->max) - fixed3232ToReal(vci->min)) * 1000.0 / vciResolution);
             }
             break;
         }
@@ -530,7 +521,8 @@ QXcbConnection::TouchDeviceData *QXcbConnection::populateTouchDevices(void *info
 
     if (type >= QTouchDevice::TouchScreen && type <= QTouchDevice::TouchPad) {
         dev.qtTouchDevice = new QTouchDevice;
-        dev.qtTouchDevice->setName(QString::fromUtf8(deviceinfo->name));
+        dev.qtTouchDevice->setName(QString::fromUtf8(xcb_input_xi_device_info_name(deviceinfo),
+                                                     xcb_input_xi_device_info_name_length(deviceinfo)));
         dev.qtTouchDevice->setType((QTouchDevice::DeviceType)type);
         dev.qtTouchDevice->setCapabilities(caps);
         dev.qtTouchDevice->setMaximumTouchPoints(maxTouchPoints);
@@ -543,49 +535,46 @@ QXcbConnection::TouchDeviceData *QXcbConnection::populateTouchDevices(void *info
     return isTouchDevice ? &m_touchDevices[deviceinfo->deviceid] : nullptr;
 }
 
-#if defined(XCB_USE_XINPUT21) || QT_CONFIG(tabletevent)
-static inline qreal fixed1616ToReal(FP1616 val)
+#if QT_CONFIG(tabletevent)
+static inline qreal fixed1616ToReal(xcb_input_fp1616_t val)
 {
     return qreal(val) / 0x10000;
 }
-#endif // defined(XCB_USE_XINPUT21) || QT_CONFIG(tabletevent)
+#endif // QT_CONFIG(tabletevent)
 
 void QXcbConnection::xi2HandleEvent(xcb_ge_event_t *event)
 {
-    xi2PrepareXIGenericDeviceEvent(event);
-    xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
+    auto *xiEvent = reinterpret_cast<qt_xcb_input_device_event_t *>(event);
     int sourceDeviceId = xiEvent->deviceid; // may be the master id
-    xXIDeviceEvent *xiDeviceEvent = 0;
-    xXIEnterEvent *xiEnterEvent = 0;
+    qt_xcb_input_device_event_t *xiDeviceEvent = nullptr;
+    xcb_input_enter_event_t *xiEnterEvent = nullptr;
     QXcbWindowEventListener *eventListener = 0;
 
-    switch (xiEvent->evtype) {
-    case XI_ButtonPress:
-    case XI_ButtonRelease:
-    case XI_Motion:
-#ifdef XCB_USE_XINPUT22
-    case XI_TouchBegin:
-    case XI_TouchUpdate:
-    case XI_TouchEnd:
-#endif
+    switch (xiEvent->event_type) {
+    case XCB_INPUT_BUTTON_PRESS:
+    case XCB_INPUT_BUTTON_RELEASE:
+    case XCB_INPUT_MOTION:
+    case XCB_INPUT_TOUCH_BEGIN:
+    case XCB_INPUT_TOUCH_UPDATE:
+    case XCB_INPUT_TOUCH_END:
     {
-        xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
+        xiDeviceEvent = xiEvent;
         eventListener = windowEventListenerFromId(xiDeviceEvent->event);
         sourceDeviceId = xiDeviceEvent->sourceid; // use the actual device id instead of the master
         break;
     }
-    case XI_Enter:
-    case XI_Leave: {
-        xiEnterEvent = reinterpret_cast<xXIEnterEvent *>(event);
+    case XCB_INPUT_ENTER:
+    case XCB_INPUT_LEAVE: {
+        xiEnterEvent = reinterpret_cast<xcb_input_enter_event_t *>(event);
         eventListener = windowEventListenerFromId(xiEnterEvent->event);
         sourceDeviceId = xiEnterEvent->sourceid; // use the actual device id instead of the master
         break;
     }
-    case XI_HierarchyChanged:
-        xi2HandleHierarchyEvent(xiEvent);
+    case XCB_INPUT_HIERARCHY:
+        xi2HandleHierarchyEvent(event);
         return;
-    case XI_DeviceChanged:
-        xi2HandleDeviceChangedEvent(xiEvent);
+    case XCB_INPUT_DEVICE_CHANGED:
+        xi2HandleDeviceChangedEvent(event);
         return;
     default:
         break;
@@ -600,32 +589,30 @@ void QXcbConnection::xi2HandleEvent(xcb_ge_event_t *event)
 #if QT_CONFIG(tabletevent)
     if (!xiEnterEvent) {
         QXcbConnection::TabletData *tablet = tabletDataForDevice(sourceDeviceId);
-        if (tablet && xi2HandleTabletEvent(xiEvent, tablet))
+        if (tablet && xi2HandleTabletEvent(event, tablet))
             return;
     }
 #endif // QT_CONFIG(tabletevent)
 
-#ifdef XCB_USE_XINPUT21
     if (ScrollingDevice *device = scrollingDeviceForId(sourceDeviceId))
-        xi2HandleScrollEvent(xiEvent, *device);
-#endif // XCB_USE_XINPUT21
+        xi2HandleScrollEvent(event, *device);
 
-#ifdef XCB_USE_XINPUT22
     if (xiDeviceEvent) {
-        switch (xiDeviceEvent->evtype) {
-        case XI_ButtonPress:
-        case XI_ButtonRelease:
-        case XI_Motion:
-            if (!xi2MouseEventsDisabled() && eventListener && !(xiDeviceEvent->flags & XIPointerEmulated))
+        switch (xiDeviceEvent->event_type) {
+        case XCB_INPUT_BUTTON_PRESS:
+        case XCB_INPUT_BUTTON_RELEASE:
+        case XCB_INPUT_MOTION:
+            if (!xi2MouseEventsDisabled() && eventListener &&
+                    !(xiDeviceEvent->flags & XCB_INPUT_POINTER_EVENT_FLAGS_POINTER_EMULATED))
                 eventListener->handleXIMouseEvent(event);
             break;
 
-        case XI_TouchBegin:
-        case XI_TouchUpdate:
-        case XI_TouchEnd:
+        case XCB_INPUT_TOUCH_BEGIN:
+        case XCB_INPUT_TOUCH_UPDATE:
+        case XCB_INPUT_TOUCH_END:
             if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
                 qCDebug(lcQpaXInputEvents, "XI2 touch event type %d seq %d detail %d pos %6.1f, %6.1f root pos %6.1f, %6.1f on window %x",
-                        event->event_type, xiDeviceEvent->sequenceNumber, xiDeviceEvent->detail,
+                        event->event_type, xiDeviceEvent->sequence, xiDeviceEvent->detail,
                         fixed1616ToReal(xiDeviceEvent->event_x), fixed1616ToReal(xiDeviceEvent->event_y),
                         fixed1616ToReal(xiDeviceEvent->root_x), fixed1616ToReal(xiDeviceEvent->root_y),xiDeviceEvent->event);
             if (QXcbWindow *platformWindow = platformWindowFromId(xiDeviceEvent->event))
@@ -633,14 +620,13 @@ void QXcbConnection::xi2HandleEvent(xcb_ge_event_t *event)
             break;
         }
     } else if (xiEnterEvent && !xi2MouseEventsDisabled() && eventListener) {
-        switch (xiEnterEvent->evtype) {
-        case XI_Enter:
-        case XI_Leave:
+        switch (xiEnterEvent->event_type) {
+        case XCB_INPUT_ENTER:
+        case XCB_INPUT_LEAVE:
             eventListener->handleXIEnterLeave(event);
             break;
         }
     }
-#endif // XCB_USE_XINPUT22
 }
 
 bool QXcbConnection::xi2MouseEventsDisabled() const
@@ -651,7 +637,6 @@ bool QXcbConnection::xi2MouseEventsDisabled() const
     return xi2MouseDisabled || has_xinerama_extension;
 }
 
-#ifdef XCB_USE_XINPUT22
 bool QXcbConnection::isTouchScreen(int id)
 {
     auto device = touchDeviceForId(id);
@@ -660,11 +645,11 @@ bool QXcbConnection::isTouchScreen(int id)
 
 void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindow)
 {
-    xXIDeviceEvent *xiDeviceEvent = static_cast<xXIDeviceEvent *>(xiDevEvent);
+    auto *xiDeviceEvent = reinterpret_cast<xcb_input_touch_begin_event_t *>(xiDevEvent);
     TouchDeviceData *dev = touchDeviceForId(xiDeviceEvent->sourceid);
     Q_ASSERT(dev);
     const bool firstTouch = dev->touchPoints.isEmpty();
-    if (xiDeviceEvent->evtype == XI_TouchBegin) {
+    if (xiDeviceEvent->event_type == XCB_INPUT_TOUCH_BEGIN) {
         QWindowSystemInterface::TouchPoint tp;
         tp.id = xiDeviceEvent->detail % INT_MAX;
         tp.state = Qt::TouchPointPressed;
@@ -735,7 +720,7 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
         y = touchPoint.area.center().y();
         ny = y / screen->geometry().height();
     }
-    if (xiDeviceEvent->evtype != XI_TouchEnd) {
+    if (xiDeviceEvent->event_type != XCB_INPUT_TOUCH_END) {
         if (!dev->providesTouchOrientation) {
             if (w == 0.0)
                 w = touchPoint.area.width();
@@ -750,8 +735,8 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
         }
     }
 
-    switch (xiDeviceEvent->evtype) {
-    case XI_TouchBegin:
+    switch (xiDeviceEvent->event_type) {
+    case XCB_INPUT_TOUCH_BEGIN:
         if (firstTouch) {
             dev->firstPressedPosition = QPointF(x, y);
             dev->firstPressedNormalPosition = QPointF(nx, ny);
@@ -761,14 +746,12 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
         // Touches must be accepted when we are grabbing touch events. Otherwise the entire sequence
         // will get replayed when the grab ends.
         if (m_xiGrab) {
-            // Note that XIAllowTouchEvents is known to deadlock with older libXi versions,
-            // for details see qtbase/src/plugins/platforms/xcb/README. This has nothing to
-            // do with the XInput protocol version, but is a bug in libXi implementation instead.
-            XIAllowTouchEvents(static_cast<Display *>(m_xlib_display), xiDeviceEvent->deviceid,
-                               xiDeviceEvent->detail, xiDeviceEvent->event, XIAcceptTouch);
+            xcb_input_xi_allow_events(m_connection, XCB_CURRENT_TIME, xiDeviceEvent->deviceid,
+                                      XCB_INPUT_EVENT_MODE_ACCEPT_TOUCH,
+                                      xiDeviceEvent->detail, xiDeviceEvent->event);
         }
         break;
-    case XI_TouchUpdate:
+    case XCB_INPUT_TOUCH_UPDATE:
         if (dev->qtTouchDevice->type() == QTouchDevice::TouchPad && dev->pointPressedPosition.value(touchPoint.id) == QPointF(x, y)) {
             qreal dx = (nx - dev->firstPressedNormalPosition.x()) *
                 dev->size.width() * screen->geometry().width() / screen->physicalSize().width();
@@ -789,14 +772,15 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
             xiDeviceEvent->detail == m_startSystemMoveResizeInfo.pointid) {
             QXcbWindow *window = platformWindowFromId(m_startSystemMoveResizeInfo.window);
             if (window) {
-                XIAllowTouchEvents(static_cast<Display *>(m_xlib_display), xiDeviceEvent->deviceid,
-                                   xiDeviceEvent->detail, xiDeviceEvent->event, XIRejectTouch);
+                xcb_input_xi_allow_events(m_connection, XCB_CURRENT_TIME, xiDeviceEvent->deviceid,
+                                          XCB_INPUT_EVENT_MODE_REJECT_TOUCH,
+                                          xiDeviceEvent->detail, xiDeviceEvent->event);
                 window->doStartSystemMoveResize(QPoint(x, y), m_startSystemMoveResizeInfo.corner);
                 m_startSystemMoveResizeInfo.window = XCB_NONE;
             }
         }
         break;
-    case XI_TouchEnd:
+    case XCB_INPUT_TOUCH_END:
         touchPoint.state = Qt::TouchPointReleased;
         if (dev->qtTouchDevice->type() == QTouchDevice::TouchPad && dev->pointPressedPosition.value(touchPoint.id) == QPointF(x, y)) {
             qreal dx = (nx - dev->firstPressedNormalPosition.x()) *
@@ -814,7 +798,7 @@ void QXcbConnection::xi2ProcessTouch(void *xiDevEvent, QXcbWindow *platformWindo
     if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
         qCDebug(lcQpaXInputEvents) << "   touchpoint "  << touchPoint.id << " state " << touchPoint.state << " pos norm " << touchPoint.normalPosition <<
             " area " << touchPoint.area << " pressure " << touchPoint.pressure;
-    Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(xiDeviceEvent->mods.effective_mods);
+    Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(xiDeviceEvent->mods.effective);
     QWindowSystemInterface::handleTouchEvent(platformWindow->window(), xiDeviceEvent->time, dev->qtTouchDevice, dev->touchPoints.values(), modifiers);
     if (touchPoint.state == Qt::TouchPointReleased)
         // If a touchpoint was released, we can forget it, because the ID won't be reused.
@@ -845,46 +829,46 @@ bool QXcbConnection::startSystemMoveResizeForTouchBegin(xcb_window_t window, con
     }
     return false;
 }
-#endif // XCB_USE_XINPUT22
 
 bool QXcbConnection::xi2SetMouseGrabEnabled(xcb_window_t w, bool grab)
 {
-    Display *xDisplay = static_cast<Display *>(xlib_display());
     bool ok = false;
 
     if (grab) { // grab
-        XIEventMask evmask;
-        unsigned char mask[XIMaskLen(XI_LASTEVENT)];
-        evmask.mask = mask;
-        evmask.mask_len = sizeof(mask);
-        memset(mask, 0, sizeof(mask));
-        XISetMask(mask, XI_ButtonPress);
-        XISetMask(mask, XI_ButtonRelease);
-        XISetMask(mask, XI_Motion);
-        XISetMask(mask, XI_Enter);
-        XISetMask(mask, XI_Leave);
-        XISetMask(mask, XI_TouchBegin);
-        XISetMask(mask, XI_TouchUpdate);
-        XISetMask(mask, XI_TouchEnd);
+        uint32_t mask = XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS
+                | XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE
+                | XCB_INPUT_XI_EVENT_MASK_MOTION
+                | XCB_INPUT_XI_EVENT_MASK_ENTER
+                | XCB_INPUT_XI_EVENT_MASK_LEAVE
+                | XCB_INPUT_XI_EVENT_MASK_TOUCH_BEGIN
+                | XCB_INPUT_XI_EVENT_MASK_TOUCH_UPDATE
+                | XCB_INPUT_XI_EVENT_MASK_TOUCH_END;
 
         for (int id : m_xiMasterPointerIds) {
-            evmask.deviceid = id;
-            Status result = XIGrabDevice(xDisplay, id, w, CurrentTime, None,
-                                         XIGrabModeAsync, XIGrabModeAsync, False, &evmask);
-            if (result != Success) {
+            xcb_generic_error_t *error = nullptr;
+            auto cookie = xcb_input_xi_grab_device(m_connection, w, XCB_CURRENT_TIME, XCB_CURSOR_NONE, id,
+                                                   XCB_INPUT_GRAB_MODE_22_ASYNC, XCB_INPUT_GRAB_MODE_22_ASYNC,
+                                                   false, 1, &mask);
+            auto *reply = xcb_input_xi_grab_device_reply(m_connection, cookie, &error);
+            if (error) {
                 qCDebug(lcQpaXInput, "failed to grab events for device %d on window %x"
-                                     "(result %d)", id, w, result);
+                                     "(error code %d)", id, w, error->error_code);
+                free(error);
             } else {
                 // Managed to grab at least one of master pointers, that should be enough
                 // to properly dismiss windows that rely on mouse grabbing.
                 ok = true;
             }
+            free(reply);
         }
     } else { // ungrab
         for (int id : m_xiMasterPointerIds) {
-            Status result = XIUngrabDevice(xDisplay, id, CurrentTime);
-            if (result != Success)
-                qCDebug(lcQpaXInput, "XIUngrabDevice failed - id: %d (result %d)", id, result);
+            auto cookie = xcb_input_xi_ungrab_device_checked(m_connection, XCB_CURRENT_TIME, id);
+            xcb_generic_error_t *error = xcb_request_check(m_connection, cookie);
+            if (error) {
+                qCDebug(lcQpaXInput, "XIUngrabDevice failed - id: %d (error code %d)", id, error->error_code);
+                free(error);
+            }
         }
         // XIUngrabDevice does not seem to wait for a reply from X server (similar to
         // xcb_ungrab_pointer). Ungrabbing won't fail, unless NoSuchExtension error
@@ -901,9 +885,9 @@ bool QXcbConnection::xi2SetMouseGrabEnabled(xcb_window_t w, bool grab)
 
 void QXcbConnection::xi2HandleHierarchyEvent(void *event)
 {
-    xXIHierarchyEvent *xiEvent = reinterpret_cast<xXIHierarchyEvent *>(event);
+    auto *xiEvent = reinterpret_cast<xcb_input_hierarchy_event_t *>(event);
     // We only care about hotplugged devices
-    if (!(xiEvent->flags & (XISlaveRemoved | XISlaveAdded)))
+    if (!(xiEvent->flags & (XCB_INPUT_HIERARCHY_MASK_SLAVE_REMOVED | XCB_INPUT_HIERARCHY_MASK_SLAVE_ADDED)))
         return;
 
     xi2SetupDevices();
@@ -920,23 +904,19 @@ void QXcbConnection::xi2HandleHierarchyEvent(void *event)
 
 void QXcbConnection::xi2HandleDeviceChangedEvent(void *event)
 {
-    xXIDeviceChangedEvent *xiEvent = reinterpret_cast<xXIDeviceChangedEvent *>(event);
+    auto *xiEvent = reinterpret_cast<xcb_input_device_changed_event_t *>(event);
     switch (xiEvent->reason) {
-    case XIDeviceChange: {
-        int nrDevices = 0;
-        Display *dpy = static_cast<Display *>(m_xlib_display);
-        XIDeviceInfo* deviceInfo = XIQueryDevice(dpy, xiEvent->sourceid, &nrDevices);
-        if (nrDevices <= 0)
+    case XCB_INPUT_CHANGE_REASON_DEVICE_CHANGE: {
+        auto reply = Q_XCB_REPLY(xcb_input_xi_query_device, m_connection, xiEvent->sourceid);
+        if (!reply || reply->num_infos <= 0)
             return;
-        xi2SetupDevice(deviceInfo);
-        XIFreeDeviceInfo(deviceInfo);
+        auto it = xcb_input_xi_query_device_infos_iterator(reply.get());
+        xi2SetupDevice(it.data);
         break;
     }
-    case XISlaveSwitch: {
-#ifdef XCB_USE_XINPUT21
+    case XCB_INPUT_CHANGE_REASON_SLAVE_SWITCH: {
         if (ScrollingDevice *scrollingDevice = scrollingDeviceForId(xiEvent->sourceid))
             xi2UpdateScrollingDevice(*scrollingDevice);
-#endif
         break;
     }
     default:
@@ -945,28 +925,28 @@ void QXcbConnection::xi2HandleDeviceChangedEvent(void *event)
     }
 }
 
-#ifdef XCB_USE_XINPUT21
 void QXcbConnection::xi2UpdateScrollingDevice(ScrollingDevice &scrollingDevice)
 {
-    int nrDevices = 0;
-    Display *dpy = static_cast<Display *>(m_xlib_display);
-    XIDeviceInfo* deviceInfo = XIQueryDevice(dpy, scrollingDevice.deviceId, &nrDevices);
-    if (nrDevices <= 0) {
+    auto reply = Q_XCB_REPLY(xcb_input_xi_query_device, m_connection, scrollingDevice.deviceId);
+    if (!reply || reply->num_infos <= 0) {
         qCDebug(lcQpaXInputDevices, "scrolling device %d no longer present", scrollingDevice.deviceId);
         return;
     }
     QPointF lastScrollPosition;
     if (lcQpaXInputEvents().isDebugEnabled())
         lastScrollPosition = scrollingDevice.lastScrollPosition;
-    for (int c = 0; c < deviceInfo->num_classes; ++c) {
-        XIAnyClassInfo *classInfo = deviceInfo->classes[c];
-        if (classInfo->type == XIValuatorClass) {
-            XIValuatorClassInfo *vci = reinterpret_cast<XIValuatorClassInfo *>(classInfo);
+
+    xcb_input_xi_device_info_t *deviceInfo = xcb_input_xi_query_device_infos_iterator(reply.get()).data;
+    auto classes_it = xcb_input_xi_device_info_classes_iterator(deviceInfo);
+    for (; classes_it.rem; xcb_input_device_class_next(&classes_it)) {
+        xcb_input_device_class_t *classInfo = classes_it.data;
+        if (classInfo->type == XCB_INPUT_DEVICE_CLASS_TYPE_VALUATOR) {
+            auto *vci = reinterpret_cast<xcb_input_valuator_class_t *>(classInfo);
             const int valuatorAtom = qatom(vci->label);
             if (valuatorAtom == QXcbAtom::RelHorizScroll || valuatorAtom == QXcbAtom::RelHorizWheel)
-                scrollingDevice.lastScrollPosition.setX(vci->value);
+                scrollingDevice.lastScrollPosition.setX(fixed3232ToReal(vci->value));
             else if (valuatorAtom == QXcbAtom::RelVertScroll || valuatorAtom == QXcbAtom::RelVertWheel)
-                scrollingDevice.lastScrollPosition.setY(vci->value);
+                scrollingDevice.lastScrollPosition.setY(fixed3232ToReal(vci->value));
         }
     }
     if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled() && lastScrollPosition != scrollingDevice.lastScrollPosition))
@@ -974,8 +954,6 @@ void QXcbConnection::xi2UpdateScrollingDevice(ScrollingDevice &scrollingDevice)
                 lastScrollPosition.x(), lastScrollPosition.y(),
                 scrollingDevice.lastScrollPosition.x(),
                 scrollingDevice.lastScrollPosition.y());
-
-    XIFreeDeviceInfo(deviceInfo);
 }
 
 void QXcbConnection::xi2UpdateScrollingDevices()
@@ -998,10 +976,9 @@ QXcbConnection::ScrollingDevice *QXcbConnection::scrollingDeviceForId(int id)
 
 void QXcbConnection::xi2HandleScrollEvent(void *event, ScrollingDevice &scrollingDevice)
 {
-    xXIGenericDeviceEvent *xiEvent = reinterpret_cast<xXIGenericDeviceEvent *>(event);
+    auto *xiDeviceEvent = reinterpret_cast<qt_xcb_input_device_event_t *>(event);
 
-    if (xiEvent->evtype == XI_Motion && scrollingDevice.orientations) {
-        xXIDeviceEvent* xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
+    if (xiDeviceEvent->event_type == XCB_INPUT_MOTION && scrollingDevice.orientations) {
         if (QXcbWindow *platformWindow = platformWindowFromId(xiDeviceEvent->event)) {
             QPoint rawDelta;
             QPoint angleDelta;
@@ -1035,16 +1012,15 @@ void QXcbConnection::xi2HandleScrollEvent(void *event, ScrollingDevice &scrollin
             if (!angleDelta.isNull()) {
                 QPoint local(fixed1616ToReal(xiDeviceEvent->event_x), fixed1616ToReal(xiDeviceEvent->event_y));
                 QPoint global(fixed1616ToReal(xiDeviceEvent->root_x), fixed1616ToReal(xiDeviceEvent->root_y));
-                Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(xiDeviceEvent->mods.effective_mods);
+                Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(xiDeviceEvent->mods.effective);
                 if (modifiers & Qt::AltModifier) {
                     std::swap(angleDelta.rx(), angleDelta.ry());
                     std::swap(rawDelta.rx(), rawDelta.ry());
                 }
-                QWindowSystemInterface::handleWheelEvent(platformWindow->window(), xiEvent->time, local, global, rawDelta, angleDelta, modifiers);
+                QWindowSystemInterface::handleWheelEvent(platformWindow->window(), xiDeviceEvent->time, local, global, rawDelta, angleDelta, modifiers);
             }
         }
-    } else if (xiEvent->evtype == XI_ButtonRelease && scrollingDevice.legacyOrientations) {
-        xXIDeviceEvent* xiDeviceEvent = reinterpret_cast<xXIDeviceEvent *>(event);
+    } else if (xiDeviceEvent->event_type == XCB_INPUT_BUTTON_RELEASE && scrollingDevice.legacyOrientations) {
         if (QXcbWindow *platformWindow = platformWindowFromId(xiDeviceEvent->event)) {
             QPoint angleDelta;
             if (scrollingDevice.legacyOrientations & Qt::Vertical) {
@@ -1062,15 +1038,14 @@ void QXcbConnection::xi2HandleScrollEvent(void *event, ScrollingDevice &scrollin
             if (!angleDelta.isNull()) {
                 QPoint local(fixed1616ToReal(xiDeviceEvent->event_x), fixed1616ToReal(xiDeviceEvent->event_y));
                 QPoint global(fixed1616ToReal(xiDeviceEvent->root_x), fixed1616ToReal(xiDeviceEvent->root_y));
-                Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(xiDeviceEvent->mods.effective_mods);
+                Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(xiDeviceEvent->mods.effective);
                 if (modifiers & Qt::AltModifier)
                     std::swap(angleDelta.rx(), angleDelta.ry());
-                QWindowSystemInterface::handleWheelEvent(platformWindow->window(), xiEvent->time, local, global, QPoint(), angleDelta, modifiers);
+                QWindowSystemInterface::handleWheelEvent(platformWindow->window(), xiDeviceEvent->time, local, global, QPoint(), angleDelta, modifiers);
             }
         }
     }
 }
-#endif // XCB_USE_XINPUT21
 
 static int xi2ValuatorOffset(const unsigned char *maskPtr, int maskLen, int number)
 {
@@ -1093,10 +1068,10 @@ static int xi2ValuatorOffset(const unsigned char *maskPtr, int maskLen, int numb
 
 bool QXcbConnection::xi2GetValuatorValueIfSet(const void *event, int valuatorNum, double *value)
 {
-    const xXIDeviceEvent *xideviceevent = static_cast<const xXIDeviceEvent *>(event);
-    const unsigned char *buttonsMaskAddr = (const unsigned char*)&xideviceevent[1];
-    const unsigned char *valuatorsMaskAddr = buttonsMaskAddr + xideviceevent->buttons_len * 4;
-    FP3232 *valuatorsValuesAddr = (FP3232*)(valuatorsMaskAddr + xideviceevent->valuators_len * 4);
+    auto *xideviceevent = static_cast<const qt_xcb_input_device_event_t *>(event);
+    auto *buttonsMaskAddr = reinterpret_cast<const unsigned char *>(&xideviceevent[1]);
+    auto *valuatorsMaskAddr = buttonsMaskAddr + xideviceevent->buttons_len * 4;
+    auto *valuatorsValuesAddr = reinterpret_cast<const xcb_input_fp3232_t *>(valuatorsMaskAddr + xideviceevent->valuators_len * 4);
 
     int valuatorOffset = xi2ValuatorOffset(valuatorsMaskAddr, xideviceevent->valuators_len, valuatorNum);
     if (valuatorOffset < 0)
@@ -1107,15 +1082,6 @@ bool QXcbConnection::xi2GetValuatorValueIfSet(const void *event, int valuatorNum
     return true;
 }
 
-void QXcbConnection::xi2PrepareXIGenericDeviceEvent(xcb_ge_event_t *event)
-{
-    // xcb event structs contain stuff that wasn't on the wire, the full_sequence field
-    // adds an extra 4 bytes and generic events cookie data is on the wire right after the standard 32 bytes.
-    // Move this data back to have the same layout in memory as it was on the wire
-    // and allow casting, overwriting the full_sequence field.
-    memmove((char*) event + 32, (char*) event + 36, event->length * 4);
-}
-
 Qt::MouseButton QXcbConnection::xiToQtMouseButton(uint32_t b)
 {
     switch (b) {
@@ -1179,31 +1145,29 @@ static const char *pointerTypeName(QTabletEvent::PointerType ptype) {
 bool QXcbConnection::xi2HandleTabletEvent(const void *event, TabletData *tabletData)
 {
     bool handled = true;
-    Display *xDisplay = static_cast<Display *>(m_xlib_display);
-    const xXIGenericDeviceEvent *xiEvent = static_cast<const xXIGenericDeviceEvent *>(event);
-    const xXIDeviceEvent *xiDeviceEvent = reinterpret_cast<const xXIDeviceEvent *>(xiEvent);
+    const auto *xiDeviceEvent = reinterpret_cast<const qt_xcb_input_device_event_t *>(event);
 
-    switch (xiEvent->evtype) {
-    case XI_ButtonPress: {
+    switch (xiDeviceEvent->event_type) {
+    case XCB_INPUT_BUTTON_PRESS: {
         Qt::MouseButton b = xiToQtMouseButton(xiDeviceEvent->detail);
         tabletData->buttons |= b;
-        xi2ReportTabletEvent(xiEvent, tabletData);
+        xi2ReportTabletEvent(event, tabletData);
         break;
     }
-    case XI_ButtonRelease: {
+    case XCB_INPUT_BUTTON_RELEASE: {
         Qt::MouseButton b = xiToQtMouseButton(xiDeviceEvent->detail);
         tabletData->buttons ^= b;
-        xi2ReportTabletEvent(xiEvent, tabletData);
+        xi2ReportTabletEvent(event, tabletData);
         break;
     }
-    case XI_Motion:
-        xi2ReportTabletEvent(xiEvent, tabletData);
+    case XCB_INPUT_MOTION:
+        xi2ReportTabletEvent(event, tabletData);
         break;
-    case XI_PropertyEvent: {
+    case XCB_INPUT_PROPERTY: {
         // This is the wacom driver's way of reporting tool proximity.
         // The evdev driver doesn't do it this way.
-        const xXIPropertyEvent *ev = reinterpret_cast<const xXIPropertyEvent *>(event);
-        if (ev->what == XIPropertyModified) {
+        const auto *ev = reinterpret_cast<const xcb_input_property_event_t *>(event);
+        if (ev->what == XCB_INPUT_PROPERTY_FLAG_MODIFIED) {
             if (ev->property == atom(QXcbAtom::WacomSerialIDs)) {
                 enum WacomSerialIndex {
                     _WACSER_USB_ID = 0,
@@ -1213,15 +1177,12 @@ bool QXcbConnection::xi2HandleTabletEvent(const void *event, TabletData *tabletD
                     _WACSER_TOOL_ID,
                     _WACSER_COUNT
                 };
-                Atom propType;
-                int propFormat;
-                unsigned long numItems, bytesAfter;
-                unsigned char *data;
-                if (XIGetProperty(xDisplay, tabletData->deviceId, ev->property, 0, 100,
-                                  0, AnyPropertyType, &propType, &propFormat,
-                                  &numItems, &bytesAfter, &data) == Success) {
-                    if (propType == atom(QXcbAtom::INTEGER) && propFormat == 32 && numItems == _WACSER_COUNT) {
-                        quint32 *ptr = reinterpret_cast<quint32 *>(data);
+
+                auto reply = Q_XCB_REPLY(xcb_input_xi_get_property, m_connection, tabletData->deviceId, 0,
+                                         ev->property, XCB_GET_PROPERTY_TYPE_ANY, 0, 100);
+                if (reply) {
+                    if (reply->type == atom(QXcbAtom::INTEGER) && reply->format == 32 && reply->num_items == _WACSER_COUNT) {
+                        quint32 *ptr = reinterpret_cast<quint32 *>(xcb_input_xi_get_property_items(reply.get()));
                         quint32 tool = ptr[_WACSER_TOOL_ID];
                         // Workaround for http://sourceforge.net/p/linuxwacom/bugs/246/
                         // e.g. on Thinkpad Helix, tool ID will be 0 and serial will be 1
@@ -1253,7 +1214,6 @@ bool QXcbConnection::xi2HandleTabletEvent(const void *event, TabletData *tabletD
                                     tabletData->deviceId, ptr[_WACSER_USB_ID], ptr[_WACSER_LAST_TOOL_SERIAL], ptr[_WACSER_LAST_TOOL_ID],
                                     ptr[_WACSER_TOOL_SERIAL], ptr[_WACSER_TOOL_ID], toolName(tabletData->tool));
                     }
-                    XFree(data);
                 }
             }
         }
@@ -1269,12 +1229,12 @@ bool QXcbConnection::xi2HandleTabletEvent(const void *event, TabletData *tabletD
 
 void QXcbConnection::xi2ReportTabletEvent(const void *event, TabletData *tabletData)
 {
-    const xXIDeviceEvent *ev = reinterpret_cast<const xXIDeviceEvent *>(event);
+    auto *ev = reinterpret_cast<const qt_xcb_input_device_event_t *>(event);
     QXcbWindow *xcbWindow = platformWindowFromId(ev->event);
     if (!xcbWindow)
         return;
     QWindow *window = xcbWindow->window();
-    const Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(ev->mods.effective_mods);
+    const Qt::KeyboardModifiers modifiers = keyboard()->translateModifiers(ev->mods.effective);
     QPointF local(fixed1616ToReal(ev->event_x), fixed1616ToReal(ev->event_y));
     QPointF global(fixed1616ToReal(ev->root_x), fixed1616ToReal(ev->root_y));
     double pressure = 0, rotation = 0, tangentialPressure = 0;
@@ -1317,7 +1277,7 @@ void QXcbConnection::xi2ReportTabletEvent(const void *event, TabletData *tabletD
         qCDebug(lcQpaXInputEvents, "XI2 event on tablet %d with tool %s type %s seq %d detail %d time %d "
             "pos %6.1f, %6.1f root pos %6.1f, %6.1f buttons 0x%x pressure %4.2lf tilt %d, %d rotation %6.2lf modifiers 0x%x",
             tabletData->deviceId, toolName(tabletData->tool), pointerTypeName(tabletData->pointerType),
-            ev->sequenceNumber, ev->detail, ev->time,
+            ev->sequence, ev->detail, ev->time,
             local.x(), local.y(), global.x(), global.y(),
             (int)tabletData->buttons, pressure, xTilt, yTilt, rotation, (int)modifiers);
 
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.cpp b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
index e4551b0139..d9cddef2d2 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
@@ -52,10 +52,8 @@
 
 #include <xkbcommon/xkbcommon-keysyms.h>
 
-#if QT_CONFIG(xinput2)
-#include <X11/extensions/XI2proto.h>
-#undef KeyPress
-#undef KeyRelease
+#if QT_CONFIG(xcb_xinput)
+#include <xcb/xinput.h>
 #endif
 QT_BEGIN_NAMESPACE
 
@@ -824,20 +822,20 @@ void QXcbKeyboard::updateXKBStateFromCore(quint16 state)
     }
 }
 
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
 void QXcbKeyboard::updateXKBStateFromXI(void *modInfo, void *groupInfo)
 {
     if (m_config && !connection()->hasXKB()) {
-        xXIModifierInfo *mods = static_cast<xXIModifierInfo *>(modInfo);
-        xXIGroupInfo *group = static_cast<xXIGroupInfo *>(groupInfo);
+        auto *mods = static_cast<xcb_input_modifier_info_t *>(modInfo);
+        auto *group = static_cast<xcb_input_group_info_t *>(groupInfo);
         const xkb_state_component changedComponents
                 = xkb_state_update_mask(m_xkbState.get(),
-                                        mods->base_mods,
-                                        mods->latched_mods,
-                                        mods->locked_mods,
-                                        group->base_group,
-                                        group->latched_group,
-                                        group->locked_group);
+                                        mods->base,
+                                        mods->latched,
+                                        mods->locked,
+                                        group->base,
+                                        group->latched,
+                                        group->locked);
 
         handleStateChanges(changedComponents);
     }
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.h b/src/plugins/platforms/xcb/qxcbkeyboard.h
index c131d69267..ab926eab84 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.h
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.h
@@ -74,7 +74,7 @@ public:
     void updateXKBMods();
     xkb_mod_mask_t xkbModMask(quint16 state);
     void updateXKBStateFromCore(quint16 state);
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     void updateXKBStateFromXI(void *modInfo, void *groupInfo);
 #endif
 #if QT_CONFIG(xkb)
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index fed096f311..a19d69af41 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -68,6 +68,9 @@
 #undef class
 #include <xcb/xfixes.h>
 #include <xcb/shape.h>
+#if QT_CONFIG(xcb_xinput)
+#include <xcb/xinput.h>
+#endif
 
 // xcb-icccm 3.8 support
 #ifdef XCB_ICCCM_NUM_WM_SIZE_HINTS_ELEMENTS
@@ -105,11 +108,6 @@
 #include <X11/Xutil.h>
 #endif
 
-#if QT_CONFIG(xinput2)
-#include <X11/extensions/XInput2.h>
-#include <X11/extensions/XI2proto.h>
-#endif
-
 #define XCOORD_MAX 16383
 enum {
     defaultWindowWidth = 160,
@@ -520,7 +518,7 @@ void QXcbWindow::create()
                         atom(QXcbAtom::_XEMBED_INFO),
                         32, 2, (void *)data);
 
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     if (connection()->hasXInput2()) {
         if (connection()->xi2MouseEventsDisabled())
             connection()->xi2SelectDeviceEventsCompatibility(m_window);
@@ -2149,7 +2147,7 @@ void QXcbWindow::handleButtonPressEvent(int event_x, int event_y, int root_x, in
     QPoint global(root_x, root_y);
 
     if (isWheel) {
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
         if (!connection()->isAtLeastXI21()) {
 #endif
             QPoint angleDelta;
@@ -2164,7 +2162,7 @@ void QXcbWindow::handleButtonPressEvent(int event_x, int event_y, int root_x, in
             if (modifiers & Qt::AltModifier)
                 std::swap(angleDelta.rx(), angleDelta.ry());
             QWindowSystemInterface::handleWheelEvent(window(), timestamp, local, global, QPoint(), angleDelta, modifiers);
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
         }
 #endif
         return;
@@ -2204,7 +2202,7 @@ static inline bool doCheckUnGrabAncestor(QXcbConnection *conn)
     if (conn) {
 
         const bool mouseButtonsPressed = (conn->buttonState() != Qt::NoButton);
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
         return mouseButtonsPressed || (conn->hasXInput2() && !conn->xi2MouseEventsDisabled());
 #else
         return mouseButtonsPressed;
@@ -2253,7 +2251,7 @@ void QXcbWindow::handleEnterNotifyEvent(int event_x, int event_y, int root_x, in
                                         quint8 mode, quint8 detail, xcb_timestamp_t timestamp)
 {
     connection()->setTime(timestamp);
-#ifdef XCB_USE_XINPUT21
+#if QT_CONFIG(xcb_xinput)
     // Updates scroll valuators, as user might have done some scrolling outside our X client.
     connection()->xi2UpdateScrollingDevices();
 #endif
@@ -2330,16 +2328,18 @@ void QXcbWindow::handleMotionNotifyEvent(const xcb_motion_notify_event_t *event)
                             event->time, QEvent::MouseMove);
 }
 
-#if QT_CONFIG(xinput2)
-static inline int fixed1616ToInt(FP1616 val)
+#if QT_CONFIG(xcb_xinput)
+static inline int fixed1616ToInt(xcb_input_fp1616_t val)
 {
     return int(qreal(val) / 0x10000);
 }
 
+#define qt_xcb_mask_is_set(ptr, event) (((unsigned char*)(ptr))[(event)>>3] & (1 << ((event) & 7)))
+
 void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event, Qt::MouseEventSource source)
 {
     QXcbConnection *conn = connection();
-    xXIDeviceEvent *ev = reinterpret_cast<xXIDeviceEvent *>(event);
+    auto *ev = reinterpret_cast<xcb_input_button_press_event_t *>(event);
 
     if (ev->buttons_len > 0) {
         unsigned char *buttonMask = (unsigned char *) &ev[1];
@@ -2347,16 +2347,16 @@ void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event, Qt::MouseEventSource
         // XIPointerEmulated being set: https://bugs.freedesktop.org/show_bug.cgi?id=98188
         // Filter them out by other attributes: when their source device is a touch screen
         // and the LMB is pressed.
-        if (XIMaskIsSet(buttonMask, 1) && conn->isTouchScreen(ev->sourceid)) {
+        if (qt_xcb_mask_is_set(buttonMask, 1) && conn->isTouchScreen(ev->sourceid)) {
             if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
                 qCDebug(lcQpaXInput, "XI2 mouse event from touch device %d was ignored", ev->sourceid);
             return;
         }
         for (int i = 1; i <= 15; ++i)
-            conn->setButtonState(conn->translateMouseButton(i), XIMaskIsSet(buttonMask, i));
+            conn->setButtonState(conn->translateMouseButton(i), qt_xcb_mask_is_set(buttonMask, i));
     }
 
-    const Qt::KeyboardModifiers modifiers = conn->keyboard()->translateModifiers(ev->mods.effective_mods);
+    const Qt::KeyboardModifiers modifiers = conn->keyboard()->translateModifiers(ev->mods.effective);
     const int event_x = fixed1616ToInt(ev->event_x);
     const int event_y = fixed1616ToInt(ev->event_y);
     const int root_x = fixed1616ToInt(ev->root_x);
@@ -2373,47 +2373,47 @@ void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event, Qt::MouseEventSource
         sourceName = me.valueToKey(source);
     }
 
-    switch (ev->evtype) {
-    case XI_ButtonPress:
+    switch (ev->event_type) {
+    case XCB_INPUT_BUTTON_PRESS:
         if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
             qCDebug(lcQpaXInputEvents, "XI2 mouse press, button %d, time %d, source %s", button, ev->time, sourceName);
         conn->setButtonState(button, true);
         handleButtonPressEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time, QEvent::MouseButtonPress, source);
         break;
-    case XI_ButtonRelease:
+    case XCB_INPUT_BUTTON_RELEASE:
         if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
             qCDebug(lcQpaXInputEvents, "XI2 mouse release, button %d, time %d, source %s", button, ev->time, sourceName);
         conn->setButtonState(button, false);
         handleButtonReleaseEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time, QEvent::MouseButtonRelease, source);
         break;
-    case XI_Motion:
+    case XCB_INPUT_MOTION:
         if (Q_UNLIKELY(lcQpaXInputEvents().isDebugEnabled()))
             qCDebug(lcQpaXInputEvents, "XI2 mouse motion %d,%d, time %d, source %s", event_x, event_y, ev->time, sourceName);
         handleMotionNotifyEvent(event_x, event_y, root_x, root_y, modifiers, ev->time, QEvent::MouseMove, source);
         break;
     default:
-        qWarning() << "Unrecognized XI2 mouse event" << ev->evtype;
+        qWarning() << "Unrecognized XI2 mouse event" << ev->event_type;
         break;
     }
 }
 
 void QXcbWindow::handleXIEnterLeave(xcb_ge_event_t *event)
 {
-    xXIEnterEvent *ev = reinterpret_cast<xXIEnterEvent *>(event);
+    auto *ev = reinterpret_cast<xcb_input_enter_event_t *>(event);
 
     // Compare the window with current mouse grabber to prevent deliver events to any other windows.
     // If leave event occurs and the window is under mouse - allow to deliver the leave event.
     QXcbWindow *mouseGrabber = connection()->mouseGrabber();
     if (mouseGrabber && mouseGrabber != this
-            && (ev->evtype != XI_Leave || QGuiApplicationPrivate::currentMouseWindow != window())) {
+            && (ev->event_type != XCB_INPUT_LEAVE || QGuiApplicationPrivate::currentMouseWindow != window())) {
         return;
     }
 
     const int root_x = fixed1616ToInt(ev->root_x);
     const int root_y = fixed1616ToInt(ev->root_y);
 
-    switch (ev->evtype) {
-    case XI_Enter: {
+    switch (ev->event_type) {
+    case XCB_INPUT_ENTER: {
         const int event_x = fixed1616ToInt(ev->event_x);
         const int event_y = fixed1616ToInt(ev->event_y);
         qCDebug(lcQpaXInputEvents, "XI2 mouse enter %d,%d, mode %d, detail %d, time %d",
@@ -2421,7 +2421,7 @@ void QXcbWindow::handleXIEnterLeave(xcb_ge_event_t *event)
         handleEnterNotifyEvent(event_x, event_y, root_x, root_y, ev->mode, ev->detail, ev->time);
         break;
     }
-    case XI_Leave:
+    case XCB_INPUT_LEAVE:
         qCDebug(lcQpaXInputEvents, "XI2 mouse leave, mode %d, detail %d, time %d",
                 ev->mode, ev->detail, ev->time);
         connection()->keyboard()->updateXKBStateFromXI(&ev->mods, &ev->group);
@@ -2563,7 +2563,7 @@ bool QXcbWindow::setMouseGrabEnabled(bool grab)
     if (grab && !connection()->canGrab())
         return false;
 
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     if (connection()->hasXInput2() && !connection()->xi2MouseEventsDisabled()) {
         bool result = connection()->xi2SetMouseGrabEnabled(m_window, grab);
         if (grab && result)
@@ -2654,7 +2654,7 @@ bool QXcbWindow::startSystemMoveResize(const QPoint &pos, int corner)
     if (!connection()->wmSupport()->isSupportedByWM(moveResize))
         return false;
     const QPoint globalPos = QHighDpi::toNativePixels(window()->mapToGlobal(pos), window()->screen());
-#ifdef XCB_USE_XINPUT22
+#if QT_CONFIG(xcb_xinput)
     if (connection()->startSystemMoveResizeForTouchBegin(m_window, globalPos, corner))
         return true;
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbwindow.h b/src/plugins/platforms/xcb/qxcbwindow.h
index 957c4e9cbd..a1f1540466 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.h
+++ b/src/plugins/platforms/xcb/qxcbwindow.h
@@ -139,7 +139,7 @@ public:
     void handleFocusInEvent(const xcb_focus_in_event_t *event) override;
     void handleFocusOutEvent(const xcb_focus_out_event_t *event) override;
     void handlePropertyNotifyEvent(const xcb_property_notify_event_t *event) override;
-#if QT_CONFIG(xinput2)
+#if QT_CONFIG(xcb_xinput)
     void handleXIMouseEvent(xcb_ge_event_t *, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized) override;
     void handleXIEnterLeave(xcb_ge_event_t *) override;
 #endif
diff --git a/src/plugins/platforms/xcb/xcb_qpa_lib.pro b/src/plugins/platforms/xcb/xcb_qpa_lib.pro
index ffc8a29116..d71aacbf96 100644
--- a/src/plugins/platforms/xcb/xcb_qpa_lib.pro
+++ b/src/plugins/platforms/xcb/xcb_qpa_lib.pro
@@ -55,11 +55,10 @@ DEFINES += QT_BUILD_XCB_PLUGIN
 
 qtConfig(xcb-xlib) {
     QMAKE_USE += xcb_xlib
+}
 
-    qtConfig(xinput2) {
-        SOURCES += qxcbconnection_xi2.cpp
-        QMAKE_USE += xinput2
-    }
+qtConfig(xcb-xinput) {
+    SOURCES += qxcbconnection_xi2.cpp
 }
 
 qtConfig(xcb-sm) {
@@ -86,6 +85,7 @@ qtConfig(vulkan) {
 } else {
     qtConfig(xkb): QMAKE_USE += xcb_xkb
     qtConfig(xcb-render): QMAKE_USE += xcb_render
+    qtConfig(xcb-xinput): QMAKE_USE += xcb_xinput
     QMAKE_USE += xcb_syslibs
 }