File indexing completed on 2024-11-24 04:55:40

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2001, 2002 Ellis Whitehead <ellis@kde.org>
     SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kglobalaccel_x11.h"
 
 #include "logging_p.h"
 #include <KKeyServer>
 #include <netwm.h>
 
 #include <QDebug>
 #include <QSocketNotifier>
 
 #include <QApplication>
 #include <QWidget>
 #include <private/qtx11extras_p.h>
 
 #include <X11/keysym.h>
 
 // xcb
 
 // It uses "explicit" as a variable name, which is not allowed in C++
 #define explicit xcb_explicit
 #include <xcb/record.h>
 #include <xcb/xcb.h>
 #include <xcb/xcb_keysyms.h>
 #include <xcb/xcbext.h>
 #include <xcb/xkb.h>
 #undef explicit
 
 // g_keyModMaskXAccel
 //  mask of modifiers which can be used in shortcuts
 //  (meta, alt, ctrl, shift)
 // g_keyModMaskXOnOrOff
 //  mask of modifiers where we don't care whether they are on or off
 //  (caps lock, num lock, scroll lock)
 static uint g_keyModMaskXAccel = 0;
 static uint g_keyModMaskXOnOrOff = 0;
 
 static void calculateGrabMasks()
 {
     g_keyModMaskXAccel = KKeyServer::accelModMaskX();
     g_keyModMaskXOnOrOff = KKeyServer::modXLock() | KKeyServer::modXNumLock() | KKeyServer::modXScrollLock() | KKeyServer::modXModeSwitch();
     // qCDebug(KGLOBALACCELD) << "g_keyModMaskXAccel = " << g_keyModMaskXAccel
     //  << "g_keyModMaskXOnOrOff = " << g_keyModMaskXOnOrOff << endl;
 }
 
 //----------------------------------------------------
 
 KGlobalAccelImpl::KGlobalAccelImpl(QObject *parent)
     : KGlobalAccelInterface(parent)
     , m_keySymbols(nullptr)
     , m_xkb_first_event(0)
 {
     Q_ASSERT(QX11Info::connection());
 
     int events = XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE;
     xcb_change_window_attributes(QX11Info::connection(), QX11Info::appRootWindow(), XCB_CW_EVENT_MASK, &events);
 
     const xcb_query_extension_reply_t *reply = xcb_get_extension_data(QX11Info::connection(), &xcb_xkb_id);
     if (reply && reply->present) {
         m_xkb_first_event = reply->first_event;
     }
 
     // We use XRecord to get the released keys because we need a way to get notified about
     // them without needing to hold a grab
     // Holding a grab would be a problem for the cases when a process (looking at you KWin's
     // toolbox) replies to a global shortcut trigger with another grab
     m_display = XOpenDisplay(nullptr);
     auto connection = xcb_connect(XDisplayString((Display *)m_display), nullptr);
     auto context = xcb_generate_id(connection);
     xcb_record_range_t range;
     memset(&range, 0, sizeof(range));
     range.device_events.first = XCB_KEY_RELEASE;
     range.device_events.last = XCB_KEY_RELEASE;
     xcb_record_client_spec_t cs = XCB_RECORD_CS_ALL_CLIENTS;
     xcb_record_create_context(connection, context, 0, 1, 1, &cs, &range);
     auto cookie = xcb_record_enable_context(connection, context);
     xcb_flush(connection);
 
     m_xrecordCookieSequence = cookie.sequence;
 
     auto m_notifier = new QSocketNotifier(xcb_get_file_descriptor(connection), QSocketNotifier::Read, this);
     connect(m_notifier, &QSocketNotifier::activated, this, [this, connection] {
         xcb_generic_event_t *event;
         while ((event = xcb_poll_for_event(connection))) {
             std::free(event);
         }
 
         xcb_record_enable_context_reply_t *reply = nullptr;
         xcb_generic_error_t *error = nullptr;
         while (m_xrecordCookieSequence && xcb_poll_for_reply(connection, m_xrecordCookieSequence, (void **)&reply, &error)) {
             // xcb_poll_for_reply may set both reply and error to null if connection has error.
             // break if xcb_connection has error, no point to continue anyway.
             if (xcb_connection_has_error(connection)) {
                 break;
             }
 
             if (error) {
                 std::free(error);
                 break;
             }
 
             if (!reply) {
                 continue;
             }
 
             QScopedPointer<xcb_record_enable_context_reply_t, QScopedPointerPodDeleter> data(reinterpret_cast<xcb_record_enable_context_reply_t *>(reply));
             xcb_key_press_event_t *events = reinterpret_cast<xcb_key_press_event_t *>(xcb_record_enable_context_data(reply));
             int nEvents = xcb_record_enable_context_data_length(reply) / sizeof(xcb_key_press_event_t);
             for (xcb_key_press_event_t *e = events; e < events + nEvents; e++) {
                 Q_ASSERT(e->response_type == XCB_KEY_RELEASE);
                 qCDebug(KGLOBALACCELD) << "Got XKeyRelease event";
                 x11KeyRelease(e);
             }
         }
     });
     m_notifier->setEnabled(true);
 
     calculateGrabMasks();
 }
 
 KGlobalAccelImpl::~KGlobalAccelImpl()
 {
     XCloseDisplay((Display *)m_display);
     if (m_keySymbols) {
         xcb_key_symbols_free(m_keySymbols);
     }
 }
 
 bool KGlobalAccelImpl::grabKey(int keyQt, bool grab)
 {
     // grabKey is called during shutdown
     // shutdown might be due to the X server being killed
     // if so, fail immediately before trying to make other xcb calls
     if (!QX11Info::connection() || xcb_connection_has_error(QX11Info::connection())) {
         return false;
     }
 
     if (!m_keySymbols) {
         m_keySymbols = xcb_key_symbols_alloc(QX11Info::connection());
         if (!m_keySymbols) {
             return false;
         }
     }
 
     if (!keyQt) {
         qCDebug(KGLOBALACCELD) << "Tried to grab key with null code.";
         return false;
     }
 
     uint keyModX;
 
     // Resolve the modifier
     if (!KKeyServer::keyQtToModX(keyQt, &keyModX)) {
         qCDebug(KGLOBALACCELD) << "keyQt (0x" << Qt::hex << keyQt << ") failed to resolve to x11 modifier";
         return false;
     }
 
     // Resolve the X symbol
     const QList<int> keySymXs(KKeyServer::keyQtToSymXs(keyQt));
     if (keySymXs.empty()) {
         qCDebug(KGLOBALACCELD) << "keyQt (0x" << Qt::hex << keyQt << ") failed to resolve to x11 keycode";
         return false;
     }
     xcb_keycode_t *keyCodes = nullptr;
     xcb_keysym_t keySymX;
     for (xcb_keysym_t sym : keySymXs) {
         keyCodes = xcb_key_symbols_get_keycode(m_keySymbols, sym);
         if (keyCodes) {
             keySymX = sym;
             break;
         }
     }
 
     if (!keyCodes) {
         return false;
     }
     int i = 0;
     bool success = !grab;
     while (keyCodes[i] != XCB_NO_SYMBOL) {
         xcb_keycode_t keyCodeX = keyCodes[i++];
 
         // Check if shift needs to be added to the grab since KKeySequenceWidget
         // can remove shift for some keys. (all the %&* and such)
         /* clang-format off */
         if (!(keyQt & Qt::SHIFT)
             && !KKeyServer::isShiftAsModifierAllowed(keyQt)
             && !(keyQt & Qt::KeypadModifier)
             && keySymX != xcb_key_symbols_get_keysym(m_keySymbols, keyCodeX, 0)
             && keySymX == xcb_key_symbols_get_keysym(m_keySymbols, keyCodeX, 1)) { /* clang-format on */
             qCDebug(KGLOBALACCELD) << "adding shift to the grab";
             keyModX |= KKeyServer::modXShift();
         }
 
         keyModX &= g_keyModMaskXAccel; // Get rid of any non-relevant bits in mod
 
         if (!keyCodeX) {
             qCDebug(KGLOBALACCELD) << "keyQt (0x" << Qt::hex << keyQt << ") was resolved to x11 keycode 0";
             continue;
         }
 
         // We'll have to grab 8 key modifier combinations in order to cover all
         //  combinations of CapsLock, NumLock, ScrollLock.
         // Does anyone with more X-savvy know how to set a mask on QX11Info::appRootWindow so that
         //  the irrelevant bits are always ignored and we can just make one XGrabKey
         //  call per accelerator? -- ellis
 #ifndef NDEBUG
         QString sDebug = QStringLiteral("\tcode: 0x%1 state: 0x%2 | ").arg(keyCodeX, 0, 16).arg(keyModX, 0, 16);
 #endif
         uint keyModMaskX = ~g_keyModMaskXOnOrOff;
         QList<xcb_void_cookie_t> cookies;
         for (uint irrelevantBitsMask = 0; irrelevantBitsMask <= 0xff; irrelevantBitsMask++) {
             if ((irrelevantBitsMask & keyModMaskX) == 0) {
 #ifndef NDEBUG
                 sDebug += QStringLiteral("0x%3, ").arg(irrelevantBitsMask, 0, 16);
 #endif
                 if (grab) {
                     cookies << xcb_grab_key_checked(QX11Info::connection(),
                                                     true,
                                                     QX11Info::appRootWindow(),
                                                     keyModX | irrelevantBitsMask,
                                                     keyCodeX,
                                                     XCB_GRAB_MODE_ASYNC,
                                                     XCB_GRAB_MODE_SYNC);
                 } else {
                     /* clang-format off */
                     cookies << xcb_ungrab_key_checked(QX11Info::connection(),
                                                       keyCodeX, QX11Info::appRootWindow(),
                                                       keyModX | irrelevantBitsMask);
                     /* clang-format on */
                 }
             }
         }
 
         bool failed = false;
         if (grab) {
             for (int i = 0; i < cookies.size(); ++i) {
                 QScopedPointer<xcb_generic_error_t, QScopedPointerPodDeleter> error(xcb_request_check(QX11Info::connection(), cookies.at(i)));
                 if (!error.isNull()) {
                     failed = true;
                 }
             }
             if (failed) {
                 qCDebug(KGLOBALACCELD) << "grab failed!\n";
                 for (uint m = 0; m <= 0xff; m++) {
                     if ((m & keyModMaskX) == 0) {
                         xcb_ungrab_key(QX11Info::connection(), keyCodeX, QX11Info::appRootWindow(), keyModX | m);
                     }
                 }
             } else {
                 success = true;
             }
         }
     }
     free(keyCodes);
     return success;
 }
 
 bool KGlobalAccelImpl::nativeEventFilter(const QByteArray &eventType, void *message, qintptr *)
 {
     if (eventType != "xcb_generic_event_t") {
         return false;
     }
     xcb_generic_event_t *event = reinterpret_cast<xcb_generic_event_t *>(message);
     const uint8_t responseType = event->response_type & ~0x80;
     if (responseType == XCB_MAPPING_NOTIFY) {
         x11MappingNotify();
 
         // Make sure to let Qt handle it as well
         return false;
     } else if (responseType == XCB_KEY_PRESS) {
         qCDebug(KGLOBALACCELD) << "Got XKeyPress event";
         return x11KeyPress(reinterpret_cast<xcb_key_press_event_t *>(event));
     } else if (m_xkb_first_event && responseType == m_xkb_first_event) {
         const uint8_t xkbEvent = event->pad0;
         switch (xkbEvent) {
         case XCB_XKB_MAP_NOTIFY:
             x11MappingNotify();
             break;
         case XCB_XKB_NEW_KEYBOARD_NOTIFY: {
             const xcb_xkb_new_keyboard_notify_event_t *ev = reinterpret_cast<xcb_xkb_new_keyboard_notify_event_t *>(event);
             if (ev->changed & XCB_XKB_NKN_DETAIL_KEYCODES) {
                 x11MappingNotify();
             }
             break;
         }
         default:
             break;
         }
 
         // Make sure to let Qt handle it as well
         return false;
     } else {
         // We get all XEvents. Just ignore them.
         return false;
     }
 }
 
 void KGlobalAccelImpl::x11MappingNotify()
 {
     qCDebug(KGLOBALACCELD) << "Got XMappingNotify event";
 
     // Maybe the X modifier map has been changed.
     // uint oldKeyModMaskXAccel = g_keyModMaskXAccel;
     // uint oldKeyModMaskXOnOrOff = g_keyModMaskXOnOrOff;
 
     // First ungrab all currently grabbed keys. This is needed because we
     // store the keys as qt keycodes and use KKeyServer to map them to x11 key
     // codes. After calling KKeyServer::initializeMods() they could map to
     // different keycodes.
     ungrabKeys();
 
     if (m_keySymbols) {
         // Force reloading of the keySym mapping
         xcb_key_symbols_free(m_keySymbols);
         m_keySymbols = nullptr;
     }
 
     KKeyServer::initializeMods();
     calculateGrabMasks();
 
     grabKeys();
 }
 
 bool KGlobalAccelImpl::x11KeyPress(xcb_key_press_event_t *pEvent)
 {
     if (QWidget::keyboardGrabber() || QApplication::activePopupWidget()) {
         qCWarning(KGLOBALACCELD) << "kglobalacceld should be popup and keyboard grabbing free!";
     }
 
     // Keyboard needs to be ungrabed after XGrabKey() activates the grab,
     // otherwise it becomes frozen.
     xcb_connection_t *c = QX11Info::connection();
     xcb_void_cookie_t cookie = xcb_ungrab_keyboard_checked(c, XCB_TIME_CURRENT_TIME);
     xcb_flush(c);
     // xcb_flush() only makes sure that the ungrab keyboard request has been
     // sent, but is not enough to make sure that request has been fulfilled. Use
     // xcb_request_check() to make sure that the request has been processed.
     xcb_request_check(c, cookie);
 
     int keyQt;
     if (!KKeyServer::xcbKeyPressEventToQt(pEvent, &keyQt)) {
         qCWarning(KGLOBALACCELD) << "KKeyServer::xcbKeyPressEventToQt failed";
         return false;
     }
     // qDebug() << "keyQt=" << QString::number(keyQt, 16);
 
     // All that work for this hey... argh...
     if (NET::timestampCompare(pEvent->time, QX11Info::appTime()) > 0) {
         QX11Info::setAppTime(pEvent->time);
     }
     return keyPressed(keyQt);
 }
 
 bool KGlobalAccelImpl::x11KeyRelease(xcb_key_press_event_t *pEvent)
 {
     if (QWidget::keyboardGrabber() || QApplication::activePopupWidget()) {
         qCWarning(KGLOBALACCELD) << "kglobalacceld should be popup and keyboard grabbing free!";
     }
 
     int keyQt;
     if (!KKeyServer::xcbKeyPressEventToQt(pEvent, &keyQt)) {
         return false;
     }
     return keyReleased(keyQt);
 }
 
 void KGlobalAccelImpl::setEnabled(bool enable)
 {
     if (enable && qApp->platformName() == QLatin1String("xcb")) {
         qApp->installNativeEventFilter(this);
     } else {
         qApp->removeNativeEventFilter(this);
     }
 }