File indexing completed on 2024-11-10 04:56:37

 /*
     KWin - the KDE window manager
     This file is part of the KDE project.
 
     SPDX-FileCopyrightText: 2015 Martin Gräßlin <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2023 Harald Sitter <sitter@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "x11_windowed_backend.h"
 #include "../common/kwinxrenderutils.h"
 
 #include <config-kwin.h>
 
 #include "utils/xcbutils.h"
 #include "x11_windowed_egl_backend.h"
 #include "x11_windowed_logging.h"
 #include "x11_windowed_output.h"
 #include "x11_windowed_qpainter_backend.h"
 #include <pointer_input.h>
 // KDE
 #include <KLocalizedString>
 #include <QAbstractEventDispatcher>
 #include <QCoreApplication>
 #include <QSocketNotifier>
 // xcb
 #include <xcb/dri3.h>
 #include <xcb/xcb_keysyms.h>
 #include <xcb/present.h>
 #include <xcb/shm.h>
 // X11
 #include <X11/Xlib-xcb.h>
 #include <fixx11h.h>
 #if HAVE_X11_XINPUT
 #include <X11/extensions/XI2proto.h>
 #include <X11/extensions/XInput2.h>
 #endif
 // system
 #include <X11/Xlib-xcb.h>
 #include <X11/keysym.h>
 #include <drm_fourcc.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <linux/input.h>
 
 namespace KWin
 {
 
 void X11WindowedInputDevice::setPointer(bool set)
 {
     m_pointer = set;
 }
 
 void X11WindowedInputDevice::setKeyboard(bool set)
 {
     m_keyboard = set;
 }
 
 void X11WindowedInputDevice::setTouch(bool set)
 {
     m_touch = set;
 }
 
 void X11WindowedInputDevice::setName(const QString &name)
 {
     m_name = name;
 }
 
 QString X11WindowedInputDevice::sysName() const
 {
     return QString();
 }
 
 QString X11WindowedInputDevice::name() const
 {
     return m_name;
 }
 
 bool X11WindowedInputDevice::isEnabled() const
 {
     return true;
 }
 
 void X11WindowedInputDevice::setEnabled(bool enabled)
 {
 }
 
 LEDs X11WindowedInputDevice::leds() const
 {
     return LEDs();
 }
 
 void X11WindowedInputDevice::setLeds(LEDs leds)
 {
 }
 
 bool X11WindowedInputDevice::isKeyboard() const
 {
     return m_keyboard;
 }
 
 bool X11WindowedInputDevice::isAlphaNumericKeyboard() const
 {
     return m_keyboard;
 }
 
 bool X11WindowedInputDevice::isPointer() const
 {
     return m_pointer;
 }
 
 bool X11WindowedInputDevice::isTouchpad() const
 {
     return false;
 }
 
 bool X11WindowedInputDevice::isTouch() const
 {
     return m_touch;
 }
 
 bool X11WindowedInputDevice::isTabletTool() const
 {
     return false;
 }
 
 bool X11WindowedInputDevice::isTabletPad() const
 {
     return false;
 }
 
 bool X11WindowedInputDevice::isTabletModeSwitch() const
 {
     return false;
 }
 
 bool X11WindowedInputDevice::isLidSwitch() const
 {
     return false;
 }
 
 X11WindowedInputBackend::X11WindowedInputBackend(X11WindowedBackend *backend)
     : m_backend(backend)
 {
 }
 
 void X11WindowedInputBackend::initialize()
 {
     if (m_backend->pointerDevice()) {
         Q_EMIT deviceAdded(m_backend->pointerDevice());
     }
     if (m_backend->keyboardDevice()) {
         Q_EMIT deviceAdded(m_backend->keyboardDevice());
     }
     if (m_backend->touchDevice()) {
         Q_EMIT deviceAdded(m_backend->touchDevice());
     }
 }
 
 X11WindowedBackend::X11WindowedBackend(const X11WindowedBackendOptions &options)
     : m_options(options)
 {
 }
 
 X11WindowedBackend::~X11WindowedBackend()
 {
     destroyOutputs();
     m_pointerDevice.reset();
     m_keyboardDevice.reset();
     m_touchDevice.reset();
     m_eglDisplay.reset();
 
     if (m_gbmDevice) {
         gbm_device_destroy(m_gbmDevice);
     }
 
     if (m_connection) {
         if (m_keySymbols) {
             xcb_key_symbols_free(m_keySymbols);
         }
         xcb_disconnect(m_connection);
         m_connection = nullptr;
     }
 }
 
 bool X11WindowedBackend::initialize()
 {
     m_display = XOpenDisplay(m_options.display.toLatin1().constData());
     if (!m_display) {
         return false;
     }
 
     m_connection = XGetXCBConnection(m_display);
     m_screenNumber = XDefaultScreen(m_display);
     XSetEventQueueOwner(m_display, XCBOwnsEventQueue);
 
     int screen = m_screenNumber;
     for (xcb_screen_iterator_t it = xcb_setup_roots_iterator(xcb_get_setup(m_connection));
             it.rem;
             --screen, xcb_screen_next(&it)) {
         if (screen == m_screenNumber) {
             m_screen = it.data;
         }
     }
 
     const xcb_query_extension_reply_t *presentExtension = xcb_get_extension_data(m_connection, &xcb_present_id);
     if (presentExtension && presentExtension->present) {
         m_presentOpcode = presentExtension->major_opcode;
         xcb_present_query_version_cookie_t cookie = xcb_present_query_version(m_connection, 1, 2);
         UniqueCPtr<xcb_present_query_version_reply_t> reply(xcb_present_query_version_reply(m_connection, cookie, nullptr));
         if (!reply) {
             qCWarning(KWIN_X11WINDOWED) << "Requested Present extension version is unsupported";
             return false;
         }
         m_presentMajorVersion = reply->major_version;
         m_presentMinorVersion = reply->minor_version;
     } else {
         qCWarning(KWIN_X11WINDOWED) << "Present X11 extension is unavailable";
         return false;
     }
 
     const xcb_query_extension_reply_t *shmExtension = xcb_get_extension_data(m_connection, &xcb_shm_id);
     if (shmExtension && shmExtension->present) {
         xcb_shm_query_version_cookie_t cookie = xcb_shm_query_version(m_connection);
         UniqueCPtr<xcb_shm_query_version_reply_t> reply(xcb_shm_query_version_reply(m_connection, cookie, nullptr));
         if (!reply) {
             qCWarning(KWIN_X11WINDOWED) << "Requested SHM extension version is unsupported";
         } else {
             if (!reply->shared_pixmaps) {
                 qCWarning(KWIN_X11WINDOWED) << "X server supports SHM extension but not shared pixmaps";
             } else {
                 m_hasShm = true;
             }
         }
     }
 
     const xcb_query_extension_reply_t *driExtension = xcb_get_extension_data(m_connection, &xcb_dri3_id);
     if (driExtension && driExtension->present) {
         xcb_dri3_query_version_cookie_t cookie = xcb_dri3_query_version(m_connection, 1, 2);
         UniqueCPtr<xcb_dri3_query_version_reply_t> reply(xcb_dri3_query_version_reply(m_connection, cookie, nullptr));
         if (reply) {
             m_hasDri = true;
             m_driMajorVersion = reply->major_version;
             m_driMinorVersion = reply->minor_version;
         } else {
             qCWarning(KWIN_X11WINDOWED) << "Requested DRI3 extension version is unsupported";
         }
     }
 
     initXInput();
     initDri3();
 
     XRenderUtils::init(m_connection, m_screen->root);
     createOutputs();
 
     m_pointerDevice = std::make_unique<X11WindowedInputDevice>();
     m_pointerDevice->setPointer(true);
     m_keyboardDevice = std::make_unique<X11WindowedInputDevice>();
     m_keyboardDevice->setKeyboard(true);
     if (m_hasXInput) {
         m_touchDevice = std::make_unique<X11WindowedInputDevice>();
         m_touchDevice->setTouch(true);
     }
 
     m_eventNotifier = std::make_unique<QSocketNotifier>(xcb_get_file_descriptor(m_connection), QSocketNotifier::Read);
     auto processXcbEvents = [this] {
         while (auto event = xcb_poll_for_event(m_connection)) {
             handleEvent(event);
             free(event);
         }
         xcb_flush(m_connection);
     };
     connect(m_eventNotifier.get(), &QSocketNotifier::activated, this, processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::aboutToBlock, this, processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::awake, this, processXcbEvents);
 
     Q_EMIT outputsQueried();
     return true;
 }
 
 void X11WindowedBackend::initXInput()
 {
 #if HAVE_X11_XINPUT
     int xi_opcode, event, error;
     // init XInput extension
     if (!XQueryExtension(m_display, "XInputExtension", &xi_opcode, &event, &error)) {
         qCDebug(KWIN_X11WINDOWED) << "XInputExtension not present";
         return;
     }
 
     // verify that the XInput extension is at at least version 2.0
     int major = 2, minor = 2;
     int result = XIQueryVersion(m_display, &major, &minor);
     if (result != Success) {
         qCDebug(KWIN_X11WINDOWED) << "Failed to init XInput 2.2, trying 2.0";
         minor = 0;
         if (XIQueryVersion(m_display, &major, &minor) != Success) {
             qCDebug(KWIN_X11WINDOWED) << "Failed to init XInput";
             return;
         }
     }
     m_xiOpcode = xi_opcode;
     m_majorVersion = major;
     m_minorVersion = minor;
     m_hasXInput = m_majorVersion >= 2 && m_minorVersion >= 2;
 #endif
 }
 
 void X11WindowedBackend::initDri3()
 {
     if (m_hasDri) {
         xcb_dri3_open_cookie_t cookie = xcb_dri3_open(m_connection, m_screen->root, 0);
         UniqueCPtr<xcb_dri3_open_reply_t> reply(xcb_dri3_open_reply(m_connection, cookie, nullptr));
         if (reply && reply->nfd == 1) {
             int fd = xcb_dri3_open_reply_fds(m_connection, reply.get())[0];
             fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
             m_drmFileDescriptor = FileDescriptor{fd};
             m_gbmDevice = gbm_create_device(m_drmFileDescriptor.get());
         }
     }
 
     xcb_depth_iterator_t it = xcb_screen_allowed_depths_iterator(m_screen);
     while (it.rem > 0) {
         uint32_t format = driFormatForDepth(it.data->depth);
         if (format) {
             QList<uint64_t> &mods = m_driFormats[format];
 
             if (m_driMajorVersion > 1 || m_driMinorVersion >= 2) {
                 xcb_dri3_get_supported_modifiers_cookie_t cookie = xcb_dri3_get_supported_modifiers(m_connection, m_screen->root, it.data->depth, 32);
                 UniqueCPtr<xcb_dri3_get_supported_modifiers_reply_t> reply(xcb_dri3_get_supported_modifiers_reply(m_connection, cookie, nullptr));
                 if (reply) {
                     const uint64_t *modifiers = xcb_dri3_get_supported_modifiers_screen_modifiers(reply.get());
                     const int modifierCount = xcb_dri3_get_supported_modifiers_screen_modifiers_length(reply.get());
                     for (int i = 0; i < modifierCount; ++i) {
                         mods.append(modifiers[i]);
                     }
                 }
             }
 
             if (mods.isEmpty()) {
                 mods.append(DRM_FORMAT_MOD_INVALID);
             }
         }
 
         xcb_depth_next(&it);
     }
 }
 
 X11WindowedOutput *X11WindowedBackend::findOutput(xcb_window_t window) const
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(),
                            [window](X11WindowedOutput *output) {
                                return output->window() == window;
                            });
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 void X11WindowedBackend::createOutputs()
 {
     Xcb::Atom protocolsAtom(QByteArrayLiteral("WM_PROTOCOLS"), false, m_connection);
     Xcb::Atom deleteWindowAtom(QByteArrayLiteral("WM_DELETE_WINDOW"), false, m_connection);
 
     // we need to multiply the initial window size with the scale in order to
     // create an output window of this size in the end
     const QSize pixelSize = m_options.outputSize * m_options.outputScale;
     for (int i = 0; i < m_options.outputCount; ++i) {
         auto *output = new X11WindowedOutput(this);
         output->init(pixelSize, m_options.outputScale);
 
         m_protocols = protocolsAtom;
         m_deleteWindowProtocol = deleteWindowAtom;
 
         xcb_change_property(m_connection,
                             XCB_PROP_MODE_REPLACE,
                             output->window(),
                             m_protocols,
                             XCB_ATOM_ATOM,
                             32, 1,
                             &m_deleteWindowProtocol);
 
         m_outputs << output;
         Q_EMIT outputAdded(output);
         output->updateEnabled(true);
     }
 
     updateWindowTitle();
 
     xcb_flush(m_connection);
 }
 
 #if HAVE_X11_XINPUT
 
 static inline qreal fixed1616ToReal(FP1616 val)
 {
     return (val)*1.0 / (1 << 16);
 }
 #endif
 
 void X11WindowedBackend::handleEvent(xcb_generic_event_t *e)
 {
     const uint8_t eventType = e->response_type & ~0x80;
     switch (eventType) {
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE:
         handleButtonPress(reinterpret_cast<xcb_button_press_event_t *>(e));
         break;
     case XCB_MOTION_NOTIFY: {
         auto event = reinterpret_cast<xcb_motion_notify_event_t *>(e);
         const X11WindowedOutput *output = findOutput(event->event);
         if (!output) {
             break;
         }
         const QPointF position = output->mapFromGlobal(QPointF(event->root_x, event->root_y));
         Q_EMIT m_pointerDevice->pointerMotionAbsolute(position, std::chrono::milliseconds(event->time), m_pointerDevice.get());
         Q_EMIT m_pointerDevice->pointerFrame(m_pointerDevice.get());
     } break;
     case XCB_KEY_PRESS:
     case XCB_KEY_RELEASE: {
         auto event = reinterpret_cast<xcb_key_press_event_t *>(e);
         if (eventType == XCB_KEY_PRESS) {
             if (!m_keySymbols) {
                 m_keySymbols = xcb_key_symbols_alloc(m_connection);
             }
             const xcb_keysym_t kc = xcb_key_symbols_get_keysym(m_keySymbols, event->detail, 0);
             if (kc == XK_Control_R) {
                 grabKeyboard(event->time);
             }
             Q_EMIT m_keyboardDevice->keyChanged(event->detail - 8,
                                                 InputRedirection::KeyboardKeyPressed,
                                                 std::chrono::milliseconds(event->time),
                                                 m_keyboardDevice.get());
         } else {
             Q_EMIT m_keyboardDevice->keyChanged(event->detail - 8,
                                                 InputRedirection::KeyboardKeyReleased,
                                                 std::chrono::milliseconds(event->time),
                                                 m_keyboardDevice.get());
         }
     } break;
     case XCB_CONFIGURE_NOTIFY:
         updateSize(reinterpret_cast<xcb_configure_notify_event_t *>(e));
         break;
     case XCB_ENTER_NOTIFY: {
         auto event = reinterpret_cast<xcb_enter_notify_event_t *>(e);
         const X11WindowedOutput *output = findOutput(event->event);
         if (!output) {
             break;
         }
         const QPointF position = output->mapFromGlobal(QPointF(event->root_x, event->root_y));
         Q_EMIT m_pointerDevice->pointerMotionAbsolute(position, std::chrono::milliseconds(event->time), m_pointerDevice.get());
     } break;
     case XCB_CLIENT_MESSAGE:
         handleClientMessage(reinterpret_cast<xcb_client_message_event_t *>(e));
         break;
     case XCB_EXPOSE:
         handleExpose(reinterpret_cast<xcb_expose_event_t *>(e));
         break;
     case XCB_MAPPING_NOTIFY:
         if (m_keySymbols) {
             xcb_refresh_keyboard_mapping(m_keySymbols, reinterpret_cast<xcb_mapping_notify_event_t *>(e));
         }
         break;
     case XCB_GE_GENERIC: {
         xcb_ge_generic_event_t *ev = reinterpret_cast<xcb_ge_generic_event_t *>(e);
         if (ev->extension == m_presentOpcode) {
             handlePresentEvent(ev);
         } else if (ev->extension == m_xiOpcode) {
             handleXinputEvent(ev);
         }
         break;
     }
     default:
         break;
     }
 }
 
 void X11WindowedBackend::grabKeyboard(xcb_timestamp_t time)
 {
     const bool oldState = m_keyboardGrabbed;
     if (m_keyboardGrabbed) {
         xcb_ungrab_keyboard(m_connection, time);
         xcb_ungrab_pointer(m_connection, time);
         m_keyboardGrabbed = false;
     } else {
         const X11WindowedOutput *output = static_cast<X11WindowedOutput *>(m_outputs[0]);
         const auto c = xcb_grab_keyboard_unchecked(m_connection, false, output->window(), time,
                                                    XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
         UniqueCPtr<xcb_grab_keyboard_reply_t> grab(xcb_grab_keyboard_reply(m_connection, c, nullptr));
         if (!grab) {
             return;
         }
         if (grab->status == XCB_GRAB_STATUS_SUCCESS) {
             const auto c = xcb_grab_pointer_unchecked(m_connection, false, output->window(),
                                                       XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
                                                       XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
                                                       output->window(), XCB_CURSOR_NONE, time);
             UniqueCPtr<xcb_grab_pointer_reply_t> grab(xcb_grab_pointer_reply(m_connection, c, nullptr));
             if (!grab || grab->status != XCB_GRAB_STATUS_SUCCESS) {
                 xcb_ungrab_keyboard(m_connection, time);
                 return;
             }
             m_keyboardGrabbed = true;
         }
     }
     if (oldState != m_keyboardGrabbed) {
         updateWindowTitle();
         xcb_flush(m_connection);
     }
 }
 
 void X11WindowedBackend::updateWindowTitle()
 {
     const QString grab = m_keyboardGrabbed ? i18n("Press right control to ungrab input") : i18n("Press right control key to grab input");
     const QString title = QStringLiteral("%1 - %2").arg(i18n("KDE Wayland Compositor"), grab);
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->setWindowTitle(title);
     }
 }
 
 void X11WindowedBackend::handleClientMessage(xcb_client_message_event_t *event)
 {
     auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                            [event](X11WindowedOutput *output) {
                                return output->window() == event->window;
                            });
     if (it == m_outputs.end()) {
         return;
     }
     if (event->type == m_protocols && m_protocols != XCB_ATOM_NONE) {
         if (event->data.data32[0] == m_deleteWindowProtocol && m_deleteWindowProtocol != XCB_ATOM_NONE) {
             if (m_outputs.count() == 1) {
                 qCDebug(KWIN_X11WINDOWED) << "Backend window is going to be closed, shutting down.";
                 QCoreApplication::quit();
             } else {
                 // remove the window
                 qCDebug(KWIN_X11WINDOWED) << "Removing one output window.";
 
                 auto removedOutput = *it;
                 it = m_outputs.erase(it);
 
                 removedOutput->updateEnabled(false);
                 Q_EMIT outputRemoved(removedOutput);
                 removedOutput->unref();
                 Q_EMIT outputsQueried();
             }
         }
     }
 }
 
 void X11WindowedBackend::handleButtonPress(xcb_button_press_event_t *event)
 {
     const X11WindowedOutput *output = findOutput(event->event);
     if (!output) {
         return;
     }
     bool const pressed = (event->response_type & ~0x80) == XCB_BUTTON_PRESS;
     if (event->detail >= XCB_BUTTON_INDEX_4 && event->detail <= 7) {
         // wheel
         if (!pressed) {
             return;
         }
         const int delta = (event->detail == XCB_BUTTON_INDEX_4 || event->detail == 6) ? -120 : 120;
         static const qreal s_defaultAxisStepDistance = 10.0;
         InputRedirection::PointerAxis axis;
         if (event->detail > 5) {
             axis = InputRedirection::PointerAxisHorizontal;
         } else {
             axis = InputRedirection::PointerAxisVertical;
         }
         Q_EMIT m_pointerDevice->pointerAxisChanged(axis,
                                                    delta * s_defaultAxisStepDistance,
                                                    delta,
                                                    InputRedirection::PointerAxisSourceUnknown,
                                                    std::chrono::milliseconds(event->time),
                                                    m_pointerDevice.get());
         Q_EMIT m_pointerDevice->pointerFrame(m_pointerDevice.get());
         return;
     }
     uint32_t button = 0;
     switch (event->detail) {
     case XCB_BUTTON_INDEX_1:
         button = BTN_LEFT;
         break;
     case XCB_BUTTON_INDEX_2:
         button = BTN_MIDDLE;
         break;
     case XCB_BUTTON_INDEX_3:
         button = BTN_RIGHT;
         break;
     default:
         button = event->detail + BTN_LEFT - 1;
         return;
     }
 
     const QPointF position = output->mapFromGlobal(QPointF(event->root_x, event->root_y));
     Q_EMIT m_pointerDevice->pointerMotionAbsolute(position, std::chrono::milliseconds(event->time), m_pointerDevice.get());
 
     if (pressed) {
         Q_EMIT m_pointerDevice->pointerButtonChanged(button, InputRedirection::PointerButtonPressed, std::chrono::milliseconds(event->time), m_pointerDevice.get());
     } else {
         Q_EMIT m_pointerDevice->pointerButtonChanged(button, InputRedirection::PointerButtonReleased, std::chrono::milliseconds(event->time), m_pointerDevice.get());
     }
     Q_EMIT m_pointerDevice->pointerFrame(m_pointerDevice.get());
 }
 
 void X11WindowedBackend::handleExpose(xcb_expose_event_t *event)
 {
     X11WindowedOutput *output = findOutput(event->window);
     if (output) {
         output->addExposedArea(QRect(event->x, event->y, event->width, event->height));
         output->renderLoop()->scheduleRepaint();
     }
 }
 
 void X11WindowedBackend::updateSize(xcb_configure_notify_event_t *event)
 {
     X11WindowedOutput *output = findOutput(event->window);
     if (!output) {
         return;
     }
 
     output->setHostPosition(QPoint(event->x, event->y));
 
     const QSize s = QSize(event->width, event->height);
     if (s != output->pixelSize()) {
         output->resize(s);
     }
 }
 
 void X11WindowedBackend::handleXinputEvent(xcb_ge_generic_event_t *ge)
 {
 #if HAVE_X11_XINPUT
     auto te = reinterpret_cast<xXIDeviceEvent *>(ge);
     const X11WindowedOutput *output = findOutput(te->event);
     if (!output) {
         return;
     }
 
     const QPointF position = output->mapFromGlobal(QPointF(fixed1616ToReal(te->root_x), fixed1616ToReal(te->root_y)));
 
     switch (ge->event_type) {
     case XI_TouchBegin: {
         Q_EMIT m_touchDevice->touchDown(te->detail, position, std::chrono::milliseconds(te->time), m_touchDevice.get());
         Q_EMIT m_touchDevice->touchFrame(m_touchDevice.get());
         break;
     }
     case XI_TouchUpdate: {
         Q_EMIT m_touchDevice->touchMotion(te->detail, position, std::chrono::milliseconds(te->time), m_touchDevice.get());
         Q_EMIT m_touchDevice->touchFrame(m_touchDevice.get());
         break;
     }
     case XI_TouchEnd: {
         Q_EMIT m_touchDevice->touchUp(te->detail, std::chrono::milliseconds(te->time), m_touchDevice.get());
         Q_EMIT m_touchDevice->touchFrame(m_touchDevice.get());
         break;
     }
     case XI_TouchOwnership: {
         auto te = reinterpret_cast<xXITouchOwnershipEvent *>(ge);
         XIAllowTouchEvents(m_display, te->deviceid, te->sourceid, te->touchid, XIAcceptTouch);
         break;
     }
     }
 #endif
 }
 
 void X11WindowedBackend::handlePresentEvent(xcb_ge_generic_event_t *ge)
 {
     switch (ge->event_type) {
     case XCB_PRESENT_EVENT_IDLE_NOTIFY: {
         xcb_present_idle_notify_event_t *idleNotify = reinterpret_cast<xcb_present_idle_notify_event_t *>(ge);
         if (X11WindowedOutput *output = findOutput(idleNotify->window)) {
             output->handlePresentIdleNotify(idleNotify);
         }
         break;
     }
     case XCB_PRESENT_EVENT_COMPLETE_NOTIFY: {
         xcb_present_complete_notify_event_t *completeNotify = reinterpret_cast<xcb_present_complete_notify_event_t *>(ge);
         if (X11WindowedOutput *output = findOutput(completeNotify->window)) {
             output->handlePresentCompleteNotify(completeNotify);
         }
         break;
     }
     }
 }
 
 xcb_window_t X11WindowedBackend::rootWindow() const
 {
     if (!m_screen) {
         return XCB_WINDOW_NONE;
     }
     return m_screen->root;
 }
 
 gbm_device *X11WindowedBackend::gbmDevice() const
 {
     return m_gbmDevice;
 }
 
 X11WindowedInputDevice *X11WindowedBackend::pointerDevice() const
 {
     return m_pointerDevice.get();
 }
 
 X11WindowedInputDevice *X11WindowedBackend::keyboardDevice() const
 {
     return m_keyboardDevice.get();
 }
 
 X11WindowedInputDevice *X11WindowedBackend::touchDevice() const
 {
     return m_touchDevice.get();
 }
 
 std::unique_ptr<OpenGLBackend> X11WindowedBackend::createOpenGLBackend()
 {
     return std::make_unique<X11WindowedEglBackend>(this);
 }
 
 std::unique_ptr<QPainterBackend> X11WindowedBackend::createQPainterBackend()
 {
     return std::make_unique<X11WindowedQPainterBackend>(this);
 }
 
 std::unique_ptr<InputBackend> X11WindowedBackend::createInputBackend()
 {
     return std::make_unique<X11WindowedInputBackend>(this);
 }
 
 xcb_connection_t *X11WindowedBackend::connection() const
 {
     return m_connection;
 }
 
 xcb_screen_t *X11WindowedBackend::screen() const
 {
     return m_screen;
 }
 
 int X11WindowedBackend::screenNumer() const
 {
     return m_screenNumber;
 }
 
 ::Display *X11WindowedBackend::display() const
 {
     return m_display;
 }
 
 bool X11WindowedBackend::hasXInput() const
 {
     return m_hasXInput;
 }
 
 QHash<uint32_t, QList<uint64_t>> X11WindowedBackend::driFormats() const
 {
     return m_driFormats;
 }
 
 uint32_t X11WindowedBackend::driFormatForDepth(int depth) const
 {
     switch (depth) {
     case 24:
         return DRM_FORMAT_XRGB8888;
     case 32:
         return DRM_FORMAT_ARGB8888;
     default:
         return 0;
     }
 }
 
 int X11WindowedBackend::driMajorVersion() const
 {
     return m_driMajorVersion;
 }
 
 int X11WindowedBackend::driMinorVersion() const
 {
     return m_driMinorVersion;
 }
 
 QList<CompositingType> X11WindowedBackend::supportedCompositors() const
 {
     QList<CompositingType> ret;
     if (m_gbmDevice) {
         ret.append(OpenGLCompositing);
     }
     if (m_hasShm) {
         ret.append(QPainterCompositing);
     }
     return ret;
 }
 
 Outputs X11WindowedBackend::outputs() const
 {
     return m_outputs;
 }
 
 void X11WindowedBackend::destroyOutputs()
 {
     while (!m_outputs.isEmpty()) {
         auto output = m_outputs.takeLast();
         output->updateEnabled(false);
         Q_EMIT outputRemoved(output);
         delete output;
     }
 }
 
 void X11WindowedBackend::setEglDisplay(std::unique_ptr<EglDisplay> &&display)
 {
     m_eglDisplay = std::move(display);
 }
 
 EglDisplay *X11WindowedBackend::sceneEglDisplayObject() const
 {
     return m_eglDisplay.get();
 }
 
 } // namespace KWin
 
 #include "moc_x11_windowed_backend.cpp"