diff --git a/xkb.cpp b/xkb.cpp index 4b99630f8..e21618dab 100644 --- a/xkb.cpp +++ b/xkb.cpp @@ -1,581 +1,581 @@ /******************************************************************** KWin - the KDE window manager This file is part of the KDE project. Copyright (C) 2013, 2016, 2017 Martin Gräßlin This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . *********************************************************************/ #include "xkb.h" #include "xkb_qt_mapping.h" #include "utils.h" // frameworks #include // KWayland #include // Qt #include #include // xkbcommon #include #include #include // system #include #include #include Q_LOGGING_CATEGORY(KWIN_XKB, "kwin_xkbcommon", QtCriticalMsg) namespace KWin { static void xkbLogHandler(xkb_context *context, xkb_log_level priority, const char *format, va_list args) { Q_UNUSED(context) char buf[1024]; if (std::vsnprintf(buf, 1023, format, args) <= 0) { return; } switch (priority) { case XKB_LOG_LEVEL_DEBUG: qCDebug(KWIN_XKB) << "XKB:" << buf; break; case XKB_LOG_LEVEL_INFO: qCInfo(KWIN_XKB) << "XKB:" << buf; break; case XKB_LOG_LEVEL_WARNING: qCWarning(KWIN_XKB) << "XKB:" << buf; break; case XKB_LOG_LEVEL_ERROR: case XKB_LOG_LEVEL_CRITICAL: default: qCCritical(KWIN_XKB) << "XKB:" << buf; break; } } Xkb::Xkb(QObject *parent) : QObject(parent) , m_context(xkb_context_new(XKB_CONTEXT_NO_FLAGS)) , m_keymap(nullptr) , m_state(nullptr) , m_shiftModifier(0) , m_capsModifier(0) , m_controlModifier(0) , m_altModifier(0) , m_metaModifier(0) , m_numModifier(0) , m_numLock(0) , m_capsLock(0) , m_scrollLock(0) , m_modifiers(Qt::NoModifier) , m_consumedModifiers(Qt::NoModifier) , m_keysym(XKB_KEY_NoSymbol) , m_leds() { qRegisterMetaType(); if (!m_context) { qCDebug(KWIN_XKB) << "Could not create xkb context"; } else { xkb_context_set_log_level(m_context, XKB_LOG_LEVEL_DEBUG); xkb_context_set_log_fn(m_context, &xkbLogHandler); // get locale as described in xkbcommon doc // cannot use QLocale as it drops the modifier part QByteArray locale = qgetenv("LC_ALL"); if (locale.isEmpty()) { locale = qgetenv("LC_CTYPE"); } if (locale.isEmpty()) { locale = qgetenv("LANG"); } if (locale.isEmpty()) { locale = QByteArrayLiteral("C"); } m_compose.table = xkb_compose_table_new_from_locale(m_context, locale.constData(), XKB_COMPOSE_COMPILE_NO_FLAGS); if (m_compose.table) { m_compose.state = xkb_compose_state_new(m_compose.table, XKB_COMPOSE_STATE_NO_FLAGS); } } } Xkb::~Xkb() { xkb_compose_state_unref(m_compose.state); xkb_compose_table_unref(m_compose.table); xkb_state_unref(m_state); xkb_keymap_unref(m_keymap); xkb_context_unref(m_context); } void Xkb::reconfigure() { if (!m_context) { return; } xkb_keymap *keymap = nullptr; if (!qEnvironmentVariableIsSet("KWIN_XKB_DEFAULT_KEYMAP")) { keymap = loadKeymapFromConfig(); } if (!keymap) { qCDebug(KWIN_XKB) << "Could not create xkb keymap from configuration"; keymap = loadDefaultKeymap(); } if (keymap) { updateKeymap(keymap); } else { qCDebug(KWIN_XKB) << "Could not create default xkb keymap"; } } static bool stringIsEmptyOrNull(const char *str) { return str == nullptr || str[0] == '\0'; } /** * libxkbcommon uses secure_getenv to read the XKB_DEFAULT_* variables. * As kwin_wayland may have the CAP_SET_NICE capability, it returns nullptr * so we need to do it ourselves (see xkb_context_sanitize_rule_names). **/ static void applyEnvironmentRules(xkb_rule_names &ruleNames) { if (stringIsEmptyOrNull(ruleNames.rules)) { ruleNames.rules = getenv("XKB_DEFAULT_RULES"); } if (stringIsEmptyOrNull(ruleNames.model)) { ruleNames.model = getenv("XKB_DEFAULT_MODEL"); } if (stringIsEmptyOrNull(ruleNames.layout)) { ruleNames.layout = getenv("XKB_DEFAULT_LAYOUT"); ruleNames.variant = getenv("XKB_DEFAULT_VARIANT"); } if (ruleNames.options == nullptr) { ruleNames.options = getenv("XKB_DEFAULT_OPTIONS"); } } xkb_keymap *Xkb::loadKeymapFromConfig() { // load config if (!m_config) { return nullptr; } const KConfigGroup config = m_config->group("Layout"); const QByteArray model = config.readEntry("Model", "pc104").toLocal8Bit(); const QByteArray layout = config.readEntry("LayoutList", "").toLocal8Bit(); const QByteArray options = config.readEntry("Options", "").toLocal8Bit(); xkb_rule_names ruleNames = { .rules = nullptr, .model = model.constData(), .layout = layout.constData(), .variant = nullptr, .options = options.constData() }; applyEnvironmentRules(ruleNames); return xkb_keymap_new_from_names(m_context, &ruleNames, XKB_KEYMAP_COMPILE_NO_FLAGS); } xkb_keymap *Xkb::loadDefaultKeymap() { xkb_rule_names ruleNames = {}; applyEnvironmentRules(ruleNames); return xkb_keymap_new_from_names(m_context, &ruleNames, XKB_KEYMAP_COMPILE_NO_FLAGS); } void Xkb::installKeymap(int fd, uint32_t size) { if (!m_context) { return; } char *map = reinterpret_cast(mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0)); if (map == MAP_FAILED) { return; } xkb_keymap *keymap = xkb_keymap_new_from_string(m_context, map, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_MAP_COMPILE_PLACEHOLDER); munmap(map, size); if (!keymap) { qCDebug(KWIN_XKB) << "Could not map keymap from file"; return; } m_ownership = Ownership::Client; updateKeymap(keymap); } void Xkb::updateKeymap(xkb_keymap *keymap) { Q_ASSERT(keymap); xkb_state *state = xkb_state_new(keymap); if (!state) { qCDebug(KWIN_XKB) << "Could not create XKB state"; xkb_keymap_unref(keymap); return; } // now release the old ones xkb_state_unref(m_state); xkb_keymap_unref(m_keymap); m_keymap = keymap; m_state = state; m_shiftModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_SHIFT); m_capsModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CAPS); m_controlModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CTRL); m_altModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_ALT); m_metaModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_LOGO); m_numModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_NUM); m_numLock = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_NUM); m_capsLock = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_CAPS); m_scrollLock = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_SCROLL); m_currentLayout = xkb_state_serialize_layout(m_state, XKB_STATE_LAYOUT_EFFECTIVE); m_modifierState.depressed = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_DEPRESSED)); m_modifierState.latched = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LATCHED)); m_modifierState.locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED)); static bool s_startup = true; if (s_startup || qEnvironmentVariableIsSet("KWIN_FORCE_NUM_LOCK_EVALUATION")) { s_startup = false; if (m_ownership == Ownership::Server && m_numModifier != XKB_MOD_INVALID && m_numLockConfig) { const KConfigGroup config = m_numLockConfig->group("Keyboard"); // STATE_ON = 0, STATE_OFF = 1, STATE_UNCHANGED = 2, see plasma-desktop/kcms/keyboard/kcmmisc.h const auto setting = config.readEntry("NumLock", 2); const bool numLockIsOn = xkb_state_mod_index_is_active(m_state, m_numModifier, XKB_STATE_MODS_LOCKED); if ((setting == 0 && !numLockIsOn) || (setting == 1 && numLockIsOn)) { std::bitset mask{m_modifierState.locked}; if (mask.size() > m_numModifier) { mask[m_numModifier] = (setting == 0); m_modifierState.locked = mask.to_ulong(); xkb_state_update_mask(m_state, m_modifierState.depressed, m_modifierState.latched, m_modifierState.locked, 0, 0, m_currentLayout); m_modifierState.locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED)); } } } } createKeymapFile(); forwardModifiers(); updateModifiers(); } void Xkb::createKeymapFile() { if (!m_seat) { return; } // TODO: uninstall keymap on server? if (!m_keymap) { return; } ScopedCPointer keymapString(xkb_keymap_get_as_string(m_keymap, XKB_KEYMAP_FORMAT_TEXT_V1)); if (keymapString.isNull()) { return; } const uint size = qstrlen(keymapString.data()) + 1; QTemporaryFile *tmp = new QTemporaryFile(this); if (!tmp->open()) { delete tmp; return; } unlink(tmp->fileName().toUtf8().constData()); if (!tmp->resize(size)) { delete tmp; return; } uchar *address = tmp->map(0, size); if (!address) { return; } if (qstrncpy(reinterpret_cast(address), keymapString.data(), size) == nullptr) { delete tmp; return; } m_seat->setKeymap(tmp->handle(), size); } void Xkb::updateModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group) { if (!m_keymap || !m_state) { return; } xkb_state_update_mask(m_state, modsDepressed, modsLatched, modsLocked, 0, 0, group); updateModifiers(); forwardModifiers(); } void Xkb::updateKey(uint32_t key, InputRedirection::KeyboardKeyState state) { if (!m_keymap || !m_state) { return; } xkb_state_update_key(m_state, key + 8, static_cast(state)); if (state == InputRedirection::KeyboardKeyPressed) { const auto sym = toKeysym(key); if (m_compose.state && xkb_compose_state_feed(m_compose.state, sym) == XKB_COMPOSE_FEED_ACCEPTED) { switch (xkb_compose_state_get_status(m_compose.state)) { case XKB_COMPOSE_NOTHING: m_keysym = sym; break; case XKB_COMPOSE_COMPOSED: m_keysym = xkb_compose_state_get_one_sym(m_compose.state); break; default: m_keysym = XKB_KEY_NoSymbol; break; } } else { m_keysym = sym; } } updateModifiers(); updateConsumedModifiers(key); } void Xkb::updateModifiers() { Qt::KeyboardModifiers mods = Qt::NoModifier; if (xkb_state_mod_index_is_active(m_state, m_shiftModifier, XKB_STATE_MODS_EFFECTIVE) == 1 || xkb_state_mod_index_is_active(m_state, m_capsModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::ShiftModifier; } if (xkb_state_mod_index_is_active(m_state, m_altModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::AltModifier; } if (xkb_state_mod_index_is_active(m_state, m_controlModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::ControlModifier; } if (xkb_state_mod_index_is_active(m_state, m_metaModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::MetaModifier; } - if (xkb_state_mod_index_is_active(m_state, m_numModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { + if (isKeypadKey(m_keysym)) { mods |= Qt::KeypadModifier; } m_modifiers = mods; // update LEDs LEDs leds; if (xkb_state_led_index_is_active(m_state, m_numLock) == 1) { leds = leds | LED::NumLock; } if (xkb_state_led_index_is_active(m_state, m_capsLock) == 1) { leds = leds | LED::CapsLock; } if (xkb_state_led_index_is_active(m_state, m_scrollLock) == 1) { leds = leds | LED::ScrollLock; } if (m_leds != leds) { m_leds = leds; emit ledsChanged(m_leds); } m_currentLayout = xkb_state_serialize_layout(m_state, XKB_STATE_LAYOUT_EFFECTIVE); m_modifierState.depressed = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_DEPRESSED)); m_modifierState.latched = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LATCHED)); m_modifierState.locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED)); } void Xkb::forwardModifiers() { if (!m_seat) { return; } m_seat->updateKeyboardModifiers(m_modifierState.depressed, m_modifierState.latched, m_modifierState.locked, m_currentLayout); } QString Xkb::layoutName() const { return layoutName(m_currentLayout); } QString Xkb::layoutName(xkb_layout_index_t layout) const { if (!m_keymap) { return QString{}; } return QString::fromLocal8Bit(xkb_keymap_layout_get_name(m_keymap, layout)); } QMap Xkb::layoutNames() const { QMap layouts; const auto size = m_keymap ? xkb_keymap_num_layouts(m_keymap) : 0u; for (xkb_layout_index_t i = 0; i < size; i++) { layouts.insert(i, layoutName(i)); } return layouts; } void Xkb::updateConsumedModifiers(uint32_t key) { Qt::KeyboardModifiers mods = Qt::NoModifier; if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_shiftModifier, XKB_CONSUMED_MODE_GTK) == 1) { mods |= Qt::ShiftModifier; } if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_altModifier, XKB_CONSUMED_MODE_GTK) == 1) { mods |= Qt::AltModifier; } if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_controlModifier, XKB_CONSUMED_MODE_GTK) == 1) { mods |= Qt::ControlModifier; } if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_metaModifier, XKB_CONSUMED_MODE_GTK) == 1) { mods |= Qt::MetaModifier; } m_consumedModifiers = mods; } Qt::KeyboardModifiers Xkb::modifiersRelevantForGlobalShortcuts() const { if (!m_state) { return Qt::NoModifier; } Qt::KeyboardModifiers mods = Qt::NoModifier; if (xkb_state_mod_index_is_active(m_state, m_shiftModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::ShiftModifier; } if (xkb_state_mod_index_is_active(m_state, m_altModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::AltModifier; } if (xkb_state_mod_index_is_active(m_state, m_controlModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::ControlModifier; } if (xkb_state_mod_index_is_active(m_state, m_metaModifier, XKB_STATE_MODS_EFFECTIVE) == 1) { mods |= Qt::MetaModifier; } Qt::KeyboardModifiers consumedMods = m_consumedModifiers; if ((mods & Qt::ShiftModifier) && (consumedMods == Qt::ShiftModifier)) { // test whether current keysym is a letter // in that case the shift should be removed from the consumed modifiers again // otherwise it would not be possible to trigger e.g. Shift+W as a shortcut // see BUG: 370341 if (QChar(toQtKey(m_keysym)).isLetter()) { consumedMods = Qt::KeyboardModifiers(); } } return mods & ~consumedMods; } xkb_keysym_t Xkb::toKeysym(uint32_t key) { if (!m_state) { return XKB_KEY_NoSymbol; } return xkb_state_key_get_one_sym(m_state, key + 8); } QString Xkb::toString(xkb_keysym_t keysym) { if (!m_state || keysym == XKB_KEY_NoSymbol) { return QString(); } QByteArray byteArray(7, 0); int ok = xkb_keysym_to_utf8(keysym, byteArray.data(), byteArray.size()); if (ok == -1 || ok == 0) { return QString(); } return QString::fromUtf8(byteArray.constData()); } Qt::Key Xkb::toQtKey(xkb_keysym_t keysym) const { return xkbToQtKey(keysym); } xkb_keysym_t Xkb::fromQtKey(Qt::Key key, Qt::KeyboardModifiers mods) const { return qtKeyToXkb(key, mods); } xkb_keysym_t Xkb::fromKeyEvent(QKeyEvent *event) const { xkb_keysym_t sym = xkb_keysym_from_name(event->text().toUtf8().constData(), XKB_KEYSYM_NO_FLAGS); if (sym == XKB_KEY_NoSymbol) { // mapping from text failed, try mapping through KKeyServer sym = fromQtKey(Qt::Key(event->key() & ~Qt::KeyboardModifierMask), event->modifiers()); } return sym; } bool Xkb::shouldKeyRepeat(quint32 key) const { if (!m_keymap) { return false; } return xkb_keymap_key_repeats(m_keymap, key + 8) != 0; } void Xkb::switchToNextLayout() { if (!m_keymap || !m_state) { return; } const xkb_layout_index_t numLayouts = xkb_keymap_num_layouts(m_keymap); const xkb_layout_index_t nextLayout = (xkb_state_serialize_layout(m_state, XKB_STATE_LAYOUT_EFFECTIVE) + 1) % numLayouts; switchToLayout(nextLayout); } void Xkb::switchToPreviousLayout() { if (!m_keymap || !m_state) { return; } const xkb_layout_index_t previousLayout = m_currentLayout == 0 ? numberOfLayouts() - 1 : m_currentLayout -1; switchToLayout(previousLayout); } void Xkb::switchToLayout(xkb_layout_index_t layout) { if (!m_keymap || !m_state) { return; } if (layout >= numberOfLayouts()) { return; } const xkb_mod_mask_t depressed = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_DEPRESSED)); const xkb_mod_mask_t latched = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LATCHED)); const xkb_mod_mask_t locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED)); xkb_state_update_mask(m_state, depressed, latched, locked, 0, 0, layout); updateModifiers(); forwardModifiers(); } quint32 Xkb::numberOfLayouts() const { if (!m_keymap) { return 0; } return xkb_keymap_num_layouts(m_keymap); } void Xkb::setSeat(KWayland::Server::SeatInterface *seat) { m_seat = QPointer(seat); } } diff --git a/xkb_qt_mapping.h b/xkb_qt_mapping.h index d927b4937..3c87f4804 100644 --- a/xkb_qt_mapping.h +++ b/xkb_qt_mapping.h @@ -1,317 +1,322 @@ /******************************************************************** KWin - the KDE window manager This file is part of the KDE project. Copyright (C) 2017 Martin Flöser This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . *********************************************************************/ #ifndef KWIN_XKB_QT_MAPPING_H #define KWIN_XKB_QT_MAPPING_H #include #include #include namespace KWin { // based on mapping in kwindowsystem/src/platforms/xcb/kkeyserver.cpp // adjusted to XKB static const std::map s_mapping{ { XKB_KEY_Escape, Qt::Key_Escape }, { XKB_KEY_Tab, Qt::Key_Tab }, { XKB_KEY_ISO_Left_Tab, Qt::Key_Backtab }, { XKB_KEY_BackSpace, Qt::Key_Backspace }, { XKB_KEY_Return, Qt::Key_Return }, { XKB_KEY_Insert, Qt::Key_Insert }, { XKB_KEY_Delete, Qt::Key_Delete }, { XKB_KEY_Pause, Qt::Key_Pause }, { XKB_KEY_Print, Qt::Key_Print }, { XKB_KEY_Sys_Req, Qt::Key_SysReq }, { XKB_KEY_Home, Qt::Key_Home }, { XKB_KEY_End, Qt::Key_End }, { XKB_KEY_Left, Qt::Key_Left }, { XKB_KEY_Up, Qt::Key_Up }, { XKB_KEY_Right, Qt::Key_Right }, { XKB_KEY_Down, Qt::Key_Down }, { XKB_KEY_Prior, Qt::Key_PageUp }, { XKB_KEY_Next, Qt::Key_PageDown }, { XKB_KEY_Caps_Lock, Qt::Key_CapsLock }, { XKB_KEY_Num_Lock, Qt::Key_NumLock }, { XKB_KEY_Scroll_Lock, Qt::Key_ScrollLock }, { XKB_KEY_F1, Qt::Key_F1 }, { XKB_KEY_F2, Qt::Key_F2 }, { XKB_KEY_F3, Qt::Key_F3 }, { XKB_KEY_F4, Qt::Key_F4 }, { XKB_KEY_F5, Qt::Key_F5 }, { XKB_KEY_F6, Qt::Key_F6 }, { XKB_KEY_F7, Qt::Key_F7 }, { XKB_KEY_F8, Qt::Key_F8 }, { XKB_KEY_F9, Qt::Key_F9 }, { XKB_KEY_F10, Qt::Key_F10 }, { XKB_KEY_F11, Qt::Key_F11 }, { XKB_KEY_F12, Qt::Key_F12 }, { XKB_KEY_F13, Qt::Key_F13 }, { XKB_KEY_F14, Qt::Key_F14 }, { XKB_KEY_F15, Qt::Key_F15 }, { XKB_KEY_F16, Qt::Key_F16 }, { XKB_KEY_F17, Qt::Key_F17 }, { XKB_KEY_F18, Qt::Key_F18 }, { XKB_KEY_F19, Qt::Key_F19 }, { XKB_KEY_F20, Qt::Key_F20 }, { XKB_KEY_F21, Qt::Key_F21 }, { XKB_KEY_F22, Qt::Key_F22 }, { XKB_KEY_F23, Qt::Key_F23 }, { XKB_KEY_F24, Qt::Key_F24 }, { XKB_KEY_F25, Qt::Key_F25 }, { XKB_KEY_F26, Qt::Key_F26 }, { XKB_KEY_F27, Qt::Key_F27 }, { XKB_KEY_F28, Qt::Key_F28 }, { XKB_KEY_F29, Qt::Key_F29 }, { XKB_KEY_F30, Qt::Key_F30 }, { XKB_KEY_F31, Qt::Key_F31 }, { XKB_KEY_F32, Qt::Key_F32 }, { XKB_KEY_F33, Qt::Key_F33 }, { XKB_KEY_F34, Qt::Key_F34 }, { XKB_KEY_F35, Qt::Key_F35 }, { XKB_KEY_Super_L, Qt::Key_Super_L }, { XKB_KEY_Super_R, Qt::Key_Super_R }, { XKB_KEY_Menu, Qt::Key_Menu }, { XKB_KEY_Hyper_L, Qt::Key_Hyper_L }, { XKB_KEY_Hyper_R, Qt::Key_Hyper_R }, { XKB_KEY_Help, Qt::Key_Help }, { XKB_KEY_KP_Space, Qt::Key_Space }, { XKB_KEY_KP_Tab, Qt::Key_Tab }, { XKB_KEY_KP_Enter, Qt::Key_Enter }, { XKB_KEY_KP_Home, Qt::Key_Home }, { XKB_KEY_KP_Left, Qt::Key_Left }, { XKB_KEY_KP_Up, Qt::Key_Up }, { XKB_KEY_KP_Right, Qt::Key_Right }, { XKB_KEY_KP_Down, Qt::Key_Down }, { XKB_KEY_KP_Prior, Qt::Key_PageUp }, { XKB_KEY_KP_Next, Qt::Key_PageDown }, { XKB_KEY_KP_End, Qt::Key_End }, { XKB_KEY_KP_Begin, Qt::Key_Clear }, { XKB_KEY_KP_Insert, Qt::Key_Insert }, { XKB_KEY_KP_Delete, Qt::Key_Delete }, { XKB_KEY_KP_Equal, Qt::Key_Equal }, { XKB_KEY_KP_Multiply, Qt::Key_Asterisk }, { XKB_KEY_KP_Add, Qt::Key_Plus }, { XKB_KEY_KP_Separator, Qt::Key_Comma }, { XKB_KEY_KP_Subtract, Qt::Key_Minus }, { XKB_KEY_KP_Decimal, Qt::Key_Period }, { XKB_KEY_KP_Divide, Qt::Key_Slash }, { XKB_KEY_XF86Back, Qt::Key_Back }, { XKB_KEY_XF86Forward, Qt::Key_Forward }, { XKB_KEY_XF86Stop, Qt::Key_Stop }, { XKB_KEY_XF86Refresh, Qt::Key_Refresh }, { XKB_KEY_XF86Favorites, Qt::Key_Favorites }, { XKB_KEY_XF86AudioMedia, Qt::Key_LaunchMedia }, { XKB_KEY_XF86OpenURL, Qt::Key_OpenUrl }, { XKB_KEY_XF86HomePage, Qt::Key_HomePage }, { XKB_KEY_XF86Search, Qt::Key_Search }, { XKB_KEY_XF86AudioLowerVolume, Qt::Key_VolumeDown }, { XKB_KEY_XF86AudioMute, Qt::Key_VolumeMute }, { XKB_KEY_XF86AudioRaiseVolume, Qt::Key_VolumeUp }, { XKB_KEY_XF86AudioPlay, Qt::Key_MediaPlay }, { XKB_KEY_XF86AudioStop, Qt::Key_MediaStop }, { XKB_KEY_XF86AudioPrev, Qt::Key_MediaPrevious }, { XKB_KEY_XF86AudioNext, Qt::Key_MediaNext }, { XKB_KEY_XF86AudioRecord, Qt::Key_MediaRecord }, { XKB_KEY_XF86Mail, Qt::Key_LaunchMail }, { XKB_KEY_XF86MyComputer, Qt::Key_Launch0 }, { XKB_KEY_XF86Calculator, Qt::Key_Launch1 }, { XKB_KEY_XF86Memo, Qt::Key_Memo }, { XKB_KEY_XF86ToDoList, Qt::Key_ToDoList }, { XKB_KEY_XF86Calendar, Qt::Key_Calendar }, { XKB_KEY_XF86PowerDown, Qt::Key_PowerDown }, { XKB_KEY_XF86ContrastAdjust, Qt::Key_ContrastAdjust }, { XKB_KEY_XF86Standby, Qt::Key_Standby }, { XKB_KEY_XF86MonBrightnessUp, Qt::Key_MonBrightnessUp }, { XKB_KEY_XF86MonBrightnessDown, Qt::Key_MonBrightnessDown }, { XKB_KEY_XF86KbdLightOnOff, Qt::Key_KeyboardLightOnOff }, { XKB_KEY_XF86KbdBrightnessUp, Qt::Key_KeyboardBrightnessUp }, { XKB_KEY_XF86KbdBrightnessDown, Qt::Key_KeyboardBrightnessDown }, { XKB_KEY_XF86PowerOff, Qt::Key_PowerOff }, { XKB_KEY_XF86WakeUp, Qt::Key_WakeUp }, { XKB_KEY_XF86Eject, Qt::Key_Eject }, { XKB_KEY_XF86ScreenSaver, Qt::Key_ScreenSaver }, { XKB_KEY_XF86WWW, Qt::Key_WWW }, { XKB_KEY_XF86Sleep, Qt::Key_Sleep }, { XKB_KEY_XF86LightBulb, Qt::Key_LightBulb }, { XKB_KEY_XF86Shop, Qt::Key_Shop }, { XKB_KEY_XF86History, Qt::Key_History }, { XKB_KEY_XF86AddFavorite, Qt::Key_AddFavorite }, { XKB_KEY_XF86HotLinks, Qt::Key_HotLinks }, { XKB_KEY_XF86BrightnessAdjust, Qt::Key_BrightnessAdjust }, { XKB_KEY_XF86Finance, Qt::Key_Finance }, { XKB_KEY_XF86Community, Qt::Key_Community }, { XKB_KEY_XF86AudioRewind, Qt::Key_AudioRewind }, { XKB_KEY_XF86BackForward, Qt::Key_BackForward }, { XKB_KEY_XF86ApplicationLeft, Qt::Key_ApplicationLeft }, { XKB_KEY_XF86ApplicationRight, Qt::Key_ApplicationRight }, { XKB_KEY_XF86Book, Qt::Key_Book }, { XKB_KEY_XF86CD, Qt::Key_CD }, { XKB_KEY_XF86Calculater, Qt::Key_Calculator }, { XKB_KEY_XF86Clear, Qt::Key_Clear }, { XKB_KEY_XF86ClearGrab, Qt::Key_ClearGrab }, { XKB_KEY_XF86Close, Qt::Key_Close }, { XKB_KEY_XF86Copy, Qt::Key_Copy }, { XKB_KEY_XF86Cut, Qt::Key_Cut }, { XKB_KEY_XF86Display, Qt::Key_Display }, { XKB_KEY_XF86DOS, Qt::Key_DOS }, { XKB_KEY_XF86Documents, Qt::Key_Documents }, { XKB_KEY_XF86Excel, Qt::Key_Excel }, { XKB_KEY_XF86Explorer, Qt::Key_Explorer }, { XKB_KEY_XF86Game, Qt::Key_Game }, { XKB_KEY_XF86Go, Qt::Key_Go }, { XKB_KEY_XF86iTouch, Qt::Key_iTouch }, { XKB_KEY_XF86LogOff, Qt::Key_LogOff }, { XKB_KEY_XF86Market, Qt::Key_Market }, { XKB_KEY_XF86Meeting, Qt::Key_Meeting }, { XKB_KEY_XF86MenuKB, Qt::Key_MenuKB }, { XKB_KEY_XF86MenuPB, Qt::Key_MenuPB }, { XKB_KEY_XF86MySites, Qt::Key_MySites }, { XKB_KEY_XF86News, Qt::Key_News }, { XKB_KEY_XF86OfficeHome, Qt::Key_OfficeHome }, { XKB_KEY_XF86Option, Qt::Key_Option }, { XKB_KEY_XF86Paste, Qt::Key_Paste }, { XKB_KEY_XF86Phone, Qt::Key_Phone }, { XKB_KEY_XF86Reply, Qt::Key_Reply }, { XKB_KEY_XF86Reload, Qt::Key_Reload }, { XKB_KEY_XF86RotateWindows, Qt::Key_RotateWindows }, { XKB_KEY_XF86RotationPB, Qt::Key_RotationPB }, { XKB_KEY_XF86RotationKB, Qt::Key_RotationKB }, { XKB_KEY_XF86Save, Qt::Key_Save }, { XKB_KEY_XF86Send, Qt::Key_Send }, { XKB_KEY_XF86Spell, Qt::Key_Spell }, { XKB_KEY_XF86SplitScreen, Qt::Key_SplitScreen }, { XKB_KEY_XF86Support, Qt::Key_Support }, { XKB_KEY_XF86TaskPane, Qt::Key_TaskPane }, { XKB_KEY_XF86Terminal, Qt::Key_Terminal }, { XKB_KEY_XF86Tools, Qt::Key_Tools }, { XKB_KEY_XF86Travel, Qt::Key_Travel }, { XKB_KEY_XF86Video, Qt::Key_Video }, { XKB_KEY_XF86Word, Qt::Key_Word }, { XKB_KEY_XF86Xfer, Qt::Key_Xfer }, { XKB_KEY_XF86ZoomIn, Qt::Key_ZoomIn }, { XKB_KEY_XF86ZoomOut, Qt::Key_ZoomOut }, { XKB_KEY_XF86Away, Qt::Key_Away }, { XKB_KEY_XF86Messenger, Qt::Key_Messenger }, { XKB_KEY_XF86WebCam, Qt::Key_WebCam }, { XKB_KEY_XF86MailForward, Qt::Key_MailForward }, { XKB_KEY_XF86Pictures, Qt::Key_Pictures }, { XKB_KEY_XF86Music, Qt::Key_Music }, { XKB_KEY_XF86Battery, Qt::Key_Battery }, { XKB_KEY_XF86Bluetooth, Qt::Key_Bluetooth }, { XKB_KEY_XF86WLAN, Qt::Key_WLAN }, { XKB_KEY_XF86UWB, Qt::Key_UWB }, { XKB_KEY_XF86AudioForward, Qt::Key_AudioForward }, { XKB_KEY_XF86AudioRepeat, Qt::Key_AudioRepeat }, { XKB_KEY_XF86AudioRandomPlay, Qt::Key_AudioRandomPlay }, { XKB_KEY_XF86Subtitle, Qt::Key_Subtitle }, { XKB_KEY_XF86AudioCycleTrack, Qt::Key_AudioCycleTrack }, { XKB_KEY_XF86Time, Qt::Key_Time }, { XKB_KEY_XF86Select, Qt::Key_Select }, { XKB_KEY_XF86View, Qt::Key_View }, { XKB_KEY_XF86TopMenu, Qt::Key_TopMenu }, { XKB_KEY_XF86Bluetooth, Qt::Key_Bluetooth }, { XKB_KEY_XF86Suspend, Qt::Key_Suspend }, { XKB_KEY_XF86Hibernate, Qt::Key_Hibernate }, { XKB_KEY_XF86TouchpadToggle, Qt::Key_TouchpadToggle }, { XKB_KEY_XF86TouchpadOn, Qt::Key_TouchpadOn }, { XKB_KEY_XF86TouchpadOff, Qt::Key_TouchpadOff }, { XKB_KEY_XF86AudioMicMute, Qt::Key_MicMute }, { XKB_KEY_XF86Launch0, Qt::Key_Launch2 }, { XKB_KEY_XF86Launch1, Qt::Key_Launch3 }, { XKB_KEY_XF86Launch2, Qt::Key_Launch4 }, { XKB_KEY_XF86Launch3, Qt::Key_Launch5 }, { XKB_KEY_XF86Launch4, Qt::Key_Launch6 }, { XKB_KEY_XF86Launch5, Qt::Key_Launch7 }, { XKB_KEY_XF86Launch6, Qt::Key_Launch8 }, { XKB_KEY_XF86Launch7, Qt::Key_Launch9 }, { XKB_KEY_XF86Launch8, Qt::Key_LaunchA }, { XKB_KEY_XF86Launch9, Qt::Key_LaunchB }, { XKB_KEY_XF86LaunchA, Qt::Key_LaunchC }, { XKB_KEY_XF86LaunchB, Qt::Key_LaunchD }, { XKB_KEY_XF86LaunchC, Qt::Key_LaunchE }, { XKB_KEY_XF86LaunchD, Qt::Key_LaunchF } }; static inline Qt::Key xkbToQtKey(xkb_keysym_t keySym) { Qt::Key key = Qt::Key_unknown; if (keySym >= XKB_KEY_KP_0 && keySym <= XKB_KEY_KP_9) { // numeric keypad keys key = Qt::Key(int(Qt::Key_0) + int(keySym) - XKB_KEY_KP_0); } else if ((keySym >= XKB_KEY_a && keySym <= XKB_KEY_z) || (keySym >= XKB_KEY_agrave && keySym < XKB_KEY_division) || (keySym > XKB_KEY_division && keySym <= XKB_KEY_thorn)) { key = Qt::Key(QChar(keySym).toUpper().unicode()); } else if (keySym < 0x3000) { key = Qt::Key(keySym); } if (key == Qt::Key_unknown) { const auto it = s_mapping.find(keySym); if (it != s_mapping.end()) { key = it->second; } } return key; } +static inline bool isKeypadKey(xkb_keysym_t keySym) +{ + return keySym >= XKB_KEY_KP_Space && keySym <= XKB_KEY_KP_9; +} + static inline xkb_keysym_t qtKeyToXkb(Qt::Key qtKey, Qt::KeyboardModifiers modifiers) { xkb_keysym_t sym = XKB_KEY_NoSymbol; if (modifiers.testFlag(Qt::KeypadModifier) && qtKey >= Qt::Key_0 && qtKey <= Qt::Key_9) { sym = XKB_KEY_KP_0 + qtKey - Qt::Key_0; } else if (qtKey < 0x1000 && !modifiers.testFlag(Qt::KeypadModifier)) { QChar character(qtKey); if (!modifiers.testFlag(Qt::ShiftModifier)) { character = character.toLower(); } sym = character.unicode(); } if (sym == XKB_KEY_NoSymbol) { std::vector possibleMatches; for (auto pair : s_mapping) { if (pair.second == qtKey) { possibleMatches.emplace_back(pair.first); } } if (!possibleMatches.empty()) { sym = possibleMatches.front(); for (auto match : possibleMatches) { // is the current match better than existing? if (modifiers.testFlag(Qt::KeypadModifier)) { - if (match >= XKB_KEY_KP_Space && match <= XKB_KEY_KP_9) { + if (isKeypadKey(match)) { sym = match; } } else { - if (sym >= XKB_KEY_KP_Space && sym <= XKB_KEY_KP_9) { + if (isKeypadKey(sym)) { sym = match; } } } } } return sym; } } #endif