8#include <qpa/qwindowsysteminterface.h>
9#include <qpa/qplatforminputcontext.h>
10#include <qpa/qplatformintegration.h>
11#include <qpa/qplatformcursor.h>
13#include <QtCore/QMetaEnum>
15#include <private/qguiapplication_p.h>
17#include <xcb/xinput.h>
24 if (
s & XCB_MOD_MASK_SHIFT)
26 if (
s & XCB_MOD_MASK_CONTROL)
28 if (
s & rmod_masks.alt)
30 if (
s & rmod_masks.meta)
32 if (
s & rmod_masks.altgr)
45 if (shifted != XKB_KEY_NoSymbol)
53 && unshifted == xupper) {
63 while (
count > 0 && symbols[
count - 1] == XKB_KEY_NoSymbol)
67 for (
int symIndex = 0; symIndex <
count; symIndex++) {
68 xcb_keysym_t sym = symbols[symIndex];
70 if (sym == XKB_KEY_NoSymbol)
71 strcpy(symString,
"NoSymbol");
73 xkb_keysym_get_name(sym, symString,
sizeof(symString));
87 keymap +=
"xkb_keymap {\n";
95 "xkb_keycodes \"core\" {\n"
98 for (
int code = minKeycode; code <= maxKeycode; code++) {
100 keymap +=
"<K" + codeStr +
"> = " + codeStr +
";\n";
110 "xkb_types \"core\" {\n"
111 "virtual_modifiers NumLock,Alt,LevelThree;\n"
112 "type \"ONE_LEVEL\" {\n"
114 "level_name[Level1] = \"Any\";\n"
116 "type \"TWO_LEVEL\" {\n"
117 "modifiers= Shift;\n"
118 "map[Shift]= Level2;\n"
119 "level_name[Level1] = \"Base\";\n"
120 "level_name[Level2] = \"Shift\";\n"
122 "type \"ALPHABETIC\" {\n"
123 "modifiers= Shift+Lock;\n"
124 "map[Shift]= Level2;\n"
125 "map[Lock]= Level2;\n"
126 "level_name[Level1] = \"Base\";\n"
127 "level_name[Level2] = \"Caps\";\n"
129 "type \"KEYPAD\" {\n"
130 "modifiers= Shift+NumLock;\n"
131 "map[Shift]= Level2;\n"
132 "map[NumLock]= Level2;\n"
133 "level_name[Level1] = \"Base\";\n"
134 "level_name[Level2] = \"Number\";\n"
136 "type \"FOUR_LEVEL\" {\n"
137 "modifiers= Shift+LevelThree;\n"
138 "map[Shift]= Level2;\n"
139 "map[LevelThree]= Level3;\n"
140 "map[Shift+LevelThree]= Level4;\n"
141 "level_name[Level1] = \"Base\";\n"
142 "level_name[Level2] = \"Shift\";\n"
143 "level_name[Level3] = \"Alt Base\";\n"
144 "level_name[Level4] = \"Shift Alt\";\n"
146 "type \"FOUR_LEVEL_ALPHABETIC\" {\n"
147 "modifiers= Shift+Lock+LevelThree;\n"
148 "map[Shift]= Level2;\n"
149 "map[Lock]= Level2;\n"
150 "map[LevelThree]= Level3;\n"
151 "map[Shift+LevelThree]= Level4;\n"
152 "map[Lock+LevelThree]= Level4;\n"
153 "map[Shift+Lock+LevelThree]= Level3;\n"
154 "level_name[Level1] = \"Base\";\n"
155 "level_name[Level2] = \"Shift\";\n"
156 "level_name[Level3] = \"Alt Base\";\n"
157 "level_name[Level4] = \"Shift Alt\";\n"
159 "type \"FOUR_LEVEL_SEMIALPHABETIC\" {\n"
160 "modifiers= Shift+Lock+LevelThree;\n"
161 "map[Shift]= Level2;\n"
162 "map[Lock]= Level2;\n"
163 "map[LevelThree]= Level3;\n"
164 "map[Shift+LevelThree]= Level4;\n"
165 "map[Lock+LevelThree]= Level3;\n"
166 "preserve[Lock+LevelThree]= Lock;\n"
167 "map[Shift+Lock+LevelThree]= Level4;\n"
168 "preserve[Shift+Lock+LevelThree]= Lock;\n"
169 "level_name[Level1] = \"Base\";\n"
170 "level_name[Level2] = \"Shift\";\n"
171 "level_name[Level3] = \"Alt Base\";\n"
172 "level_name[Level4] = \"Shift Alt\";\n"
174 "type \"FOUR_LEVEL_KEYPAD\" {\n"
175 "modifiers= Shift+NumLock+LevelThree;\n"
176 "map[Shift]= Level2;\n"
177 "map[NumLock]= Level2;\n"
178 "map[LevelThree]= Level3;\n"
179 "map[Shift+LevelThree]= Level4;\n"
180 "map[NumLock+LevelThree]= Level4;\n"
181 "map[Shift+NumLock+LevelThree]= Level3;\n"
182 "level_name[Level1] = \"Base\";\n"
183 "level_name[Level2] = \"Number\";\n"
184 "level_name[Level3] = \"Alt Base\";\n"
185 "level_name[Level4] = \"Alt Number\";\n"
191 QList<xcb_keysym_t> xkeymap;
192 int keysymsPerKeycode = 0;
194 int keycodeCount = maxKeycode - minKeycode + 1;
196 minKeycode, keycodeCount)) {
197 keysymsPerKeycode = keymapReply->keysyms_per_keycode;
198 int numSyms = keycodeCount * keysymsPerKeycode;
199 auto keymapPtr = xcb_get_keyboard_mapping_keysyms(keymapReply.get());
200 xkeymap.resize(numSyms);
201 for (
int i = 0;
i < numSyms;
i++)
202 xkeymap[
i] = keymapPtr[
i];
205 if (xkeymap.isEmpty())
208 static const char *
const builtinModifiers[] =
209 {
"Shift",
"Lock",
"Control",
"Mod1",
"Mod2",
"Mod3",
"Mod4",
"Mod5" };
216 bool mapGroup2ToLevel3 = keysymsPerKeycode < 5;
218 keymap +=
"xkb_symbols \"core\" {\n";
219 for (
int code = minKeycode; code <= maxKeycode; code++) {
220 auto codeMap = xkeymap.
constData() + (code - minKeycode) * keysymsPerKeycode;
222 const int maxGroup1 = 4;
223 const int maxGroup2 = 2;
224 xcb_keysym_t symbolsGroup1[maxGroup1];
225 xcb_keysym_t symbolsGroup2[maxGroup2] = { XKB_KEY_NoSymbol, XKB_KEY_NoSymbol };
226 for (
int i = 0;
i < maxGroup1 + maxGroup2;
i++) {
227 xcb_keysym_t sym =
i < keysymsPerKeycode ? codeMap[
i] : XKB_KEY_NoSymbol;
228 if (mapGroup2ToLevel3) {
231 symbolsGroup1[
i] = sym;
235 symbolsGroup1[
i] = sym;
237 symbolsGroup2[
i - 2] = sym;
239 symbolsGroup1[
i - 2] = sym;
246 symbolsGroup1[1] = symbolsGroup1[0];
247 symbolsGroup1[0] = lowered;
250 symbolsGroup2[1] = symbolsGroup2[0];
251 symbolsGroup2[0] = lowered;
255 if (groupStr1.isEmpty())
259 keymap +=
"symbols[Group1] = [ " + groupStr1 +
" ]";
261 if (!groupStr2.isEmpty())
262 keymap +=
", symbols[Group2] = [ " + groupStr2 +
" ]";
265 xcb_keysym_t modifierSym = XKB_KEY_NoSymbol;
266 for (
int symIndex = 0; symIndex < keysymsPerKeycode; symIndex++) {
267 xcb_keysym_t sym = codeMap[symIndex];
269 if (sym == XKB_KEY_Alt_L
270 || sym == XKB_KEY_Meta_L
271 || sym == XKB_KEY_Mode_switch
272 || sym == XKB_KEY_Super_L
273 || sym == XKB_KEY_Super_R
274 || sym == XKB_KEY_Hyper_L
275 || sym == XKB_KEY_Hyper_R) {
282 if (modifierSym == XKB_KEY_Mode_switch)
283 keymap +=
", virtualMods=LevelThree";
287 int modNum = keysymMods.value(modifierSym, -1);
290 keymap +=
QByteArray(
"modifier_map ") + builtinModifiers[modNum]
300 "xkb_compatibility \"core\" {\n"
301 "virtual_modifiers NumLock,Alt,LevelThree;\n"
302 "interpret Alt_L+AnyOf(all) {\n"
303 "virtualModifier= Alt;\n"
304 "action= SetMods(modifiers=modMapMods,clearLocks);\n"
306 "interpret Alt_R+AnyOf(all) {\n"
307 "virtualModifier= Alt;\n"
308 "action= SetMods(modifiers=modMapMods,clearLocks);\n"
317 return xkb_keymap_new_from_buffer(m_xkbContext.get(),
320 XKB_KEYMAP_FORMAT_TEXT_V1,
321 XKB_KEYMAP_COMPILE_NO_FLAGS);
329 xcb_refresh_keyboard_mapping(m_key_symbols,
event);
343 m_xkbContext.reset(xkb_context_new(XKB_CONTEXT_NO_DEFAULT_INCLUDES));
345 qCWarning(lcQpaKeyboard,
"failed to create XKB context");
349 xkb_log_level
logLevel = lcQpaKeyboard().isDebugEnabled() ?
350 XKB_LOG_LEVEL_DEBUG : XKB_LOG_LEVEL_CRITICAL;
351 xkb_context_set_log_level(m_xkbContext.get(),
logLevel);
355 m_xkbKeymap.reset(xkb_x11_keymap_new_from_device(m_xkbContext.get(),
xcb_connection(),
356 core_device_id, XKB_KEYMAP_COMPILE_NO_FLAGS));
358 m_xkbState.reset(xkb_x11_state_new_from_device(m_xkbKeymap.get(),
xcb_connection(), core_device_id));
362 m_xkbState.reset(xkb_state_new(m_xkbKeymap.get()));
366 qCWarning(lcQpaKeyboard,
"failed to compile a keymap");
371 qCWarning(lcQpaKeyboard,
"failed to create XKB state");
384 m_xkbState.get(),
event, m_superAsMeta, m_hyperAsMeta);
398 const xkb_state_component changedComponents
399 = xkb_state_update_mask(m_xkbState.get(),
413 return (
state >> 13) & 3;
419 struct xkb_state *xkbState = m_xkbState.get();
420 xkb_mod_mask_t modsDepressed = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_DEPRESSED);
421 xkb_mod_mask_t modsLatched = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LATCHED);
422 xkb_mod_mask_t modsLocked = xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LOCKED);
425 xkb_mod_mask_t latched = modsLatched & xkbMask;
426 xkb_mod_mask_t locked = modsLocked & xkbMask;
427 xkb_mod_mask_t depressed = modsDepressed & xkbMask;
429 depressed |= ~(depressed | latched | locked) & xkbMask;
431 xkb_state_component changedComponents = xkb_state_update_mask(
441 auto *mods =
static_cast<xcb_input_modifier_info_t *
>(modInfo);
442 auto *
group =
static_cast<xcb_input_group_info_t *
>(groupInfo);
443 const xkb_state_component changedComponents
444 = xkb_state_update_mask(m_xkbState.get(),
461 if ((changedComponents & XKB_STATE_LAYOUT_EFFECTIVE) == XKB_STATE_LAYOUT_EFFECTIVE)
462 qCDebug(lcQpaKeyboard,
"TODO: Support KeyboardLayoutChange on QPA (QTBUG-27681)");
467 xkb_mod_mask_t xkb_mask = 0;
469 if ((
state & XCB_MOD_MASK_SHIFT) && xkb_mods.shift != XKB_MOD_INVALID)
470 xkb_mask |= (1 << xkb_mods.shift);
471 if ((
state & XCB_MOD_MASK_LOCK) && xkb_mods.lock != XKB_MOD_INVALID)
472 xkb_mask |= (1 << xkb_mods.lock);
473 if ((
state & XCB_MOD_MASK_CONTROL) && xkb_mods.control != XKB_MOD_INVALID)
474 xkb_mask |= (1 << xkb_mods.control);
475 if ((
state & XCB_MOD_MASK_1) && xkb_mods.mod1 != XKB_MOD_INVALID)
476 xkb_mask |= (1 << xkb_mods.mod1);
477 if ((
state & XCB_MOD_MASK_2) && xkb_mods.mod2 != XKB_MOD_INVALID)
478 xkb_mask |= (1 << xkb_mods.mod2);
479 if ((
state & XCB_MOD_MASK_3) && xkb_mods.mod3 != XKB_MOD_INVALID)
480 xkb_mask |= (1 << xkb_mods.mod3);
481 if ((
state & XCB_MOD_MASK_4) && xkb_mods.mod4 != XKB_MOD_INVALID)
482 xkb_mask |= (1 << xkb_mods.mod4);
483 if ((
state & XCB_MOD_MASK_5) && xkb_mods.mod5 != XKB_MOD_INVALID)
484 xkb_mask |= (1 << xkb_mods.mod5);
492 xkb_mods.lock = xkb_keymap_mod_get_index(m_xkbKeymap.get(), XKB_MOD_NAME_CAPS);
493 xkb_mods.control = xkb_keymap_mod_get_index(m_xkbKeymap.get(),
XKB_MOD_NAME_CTRL);
494 xkb_mods.mod1 = xkb_keymap_mod_get_index(m_xkbKeymap.get(),
"Mod1");
495 xkb_mods.mod2 = xkb_keymap_mod_get_index(m_xkbKeymap.get(),
"Mod2");
496 xkb_mods.mod3 = xkb_keymap_mod_get_index(m_xkbKeymap.get(),
"Mod3");
497 xkb_mods.mod4 = xkb_keymap_mod_get_index(m_xkbKeymap.get(),
"Mod4");
498 xkb_mods.mod5 = xkb_keymap_mod_get_index(m_xkbKeymap.get(),
"Mod5");
507 core_device_id = xkb_x11_get_core_keyboard_device_id(
xcb_connection());
508 if (core_device_id == -1) {
509 qCWarning(lcQpaXcb,
"failed to get core keyboard device info");
522 xcb_key_symbols_free(m_key_symbols);
533 const uint16_t required_map_parts = (XCB_XKB_MAP_PART_KEY_TYPES |
534 XCB_XKB_MAP_PART_KEY_SYMS |
535 XCB_XKB_MAP_PART_MODIFIER_MAP |
536 XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
537 XCB_XKB_MAP_PART_KEY_ACTIONS |
538 XCB_XKB_MAP_PART_KEY_BEHAVIORS |
539 XCB_XKB_MAP_PART_VIRTUAL_MODS |
540 XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP);
542 const uint16_t required_events = (XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
543 XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
544 XCB_XKB_EVENT_TYPE_STATE_NOTIFY);
548 xcb_void_cookie_t
select = xcb_xkb_select_events_checked(
550 XCB_XKB_ID_USE_CORE_KBD,
561 qCWarning(lcQpaXcb,
"failed to select notify events from XKB");
567 xcb_xkb_get_names_value_list_t names_list;
569 memset(&vmod_masks, 0,
sizeof(vmod_masks));
572 XCB_XKB_ID_USE_CORE_KBD,
573 XCB_XKB_NAME_DETAIL_VIRTUAL_MOD_NAMES);
575 qWarning(
"Qt: failed to retrieve the virtual modifier names from XKB");
579 const void *
buffer = xcb_xkb_get_names_value_list(name_reply.get());
580 xcb_xkb_get_names_value_list_unpack(
buffer,
582 name_reply->indicators,
583 name_reply->virtualMods,
584 name_reply->groupNames,
586 name_reply->nKeyAliases,
587 name_reply->nRadioGroups,
594 vmod_mask = name_reply->virtualMods;
596 for (bit = 1; vmod_mask; bit <<= 1) {
599 if (!(vmod_mask & bit))
606 vmod_name = atomName.
data();
613 if (
qstrcmp(vmod_name,
"Alt") == 0)
614 vmod_masks.alt = bit;
615 else if (
qstrcmp(vmod_name,
"Meta") == 0)
616 vmod_masks.meta = bit;
617 else if (
qstrcmp(vmod_name,
"AltGr") == 0)
618 vmod_masks.altgr = bit;
619 else if (
qstrcmp(vmod_name,
"Super") == 0)
620 vmod_masks.super = bit;
621 else if (
qstrcmp(vmod_name,
"Hyper") == 0)
622 vmod_masks.hyper = bit;
628 xcb_xkb_get_map_map_t
map;
630 memset(&rmod_masks, 0,
sizeof(rmod_masks));
634 XCB_XKB_ID_USE_CORE_KBD,
635 XCB_XKB_MAP_PART_VIRTUAL_MODS,
636 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
638 qWarning(
"Qt: failed to retrieve the virtual modifier map from XKB");
642 const void *
buffer = xcb_xkb_get_map_map(map_reply.get());
643 xcb_xkb_get_map_map_unpack(
buffer,
646 map_reply->nKeyActions,
647 map_reply->totalActions,
648 map_reply->totalKeyBehaviors,
649 map_reply->nVModMapKeys,
650 map_reply->totalKeyExplicit,
651 map_reply->totalModMapKeys,
652 map_reply->totalVModMapKeys,
659 vmod_mask = map_reply->virtualMods;
662 for (bit = 1; vmod_mask; bit <<= 1) {
665 if (!(vmod_mask & bit))
673 if (vmod_masks.alt == bit)
674 rmod_masks.alt = modmap;
675 else if (vmod_masks.meta == bit)
676 rmod_masks.meta = modmap;
677 else if (vmod_masks.altgr == bit)
678 rmod_masks.altgr = modmap;
679 else if (vmod_masks.super == bit)
680 rmod_masks.super = modmap;
681 else if (vmod_masks.hyper == bit)
682 rmod_masks.hyper = modmap;
689 if (modifierBit >= 0 && modifierBit < 8)
690 *
mask |= 1 << modifierBit;
699 memset(&rmod_masks, 0,
sizeof(rmod_masks));
701 applyModifier(&rmod_masks.alt, keysymMods.value(XKB_KEY_Alt_L, -1));
702 applyModifier(&rmod_masks.alt, keysymMods.value(XKB_KEY_Alt_R, -1));
703 applyModifier(&rmod_masks.meta, keysymMods.value(XKB_KEY_Meta_L, -1));
704 applyModifier(&rmod_masks.meta, keysymMods.value(XKB_KEY_Meta_R, -1));
705 applyModifier(&rmod_masks.altgr, keysymMods.value(XKB_KEY_Mode_switch, -1));
706 applyModifier(&rmod_masks.super, keysymMods.value(XKB_KEY_Super_L, -1));
707 applyModifier(&rmod_masks.super, keysymMods.value(XKB_KEY_Super_R, -1));
708 applyModifier(&rmod_masks.hyper, keysymMods.value(XKB_KEY_Hyper_L, -1));
709 applyModifier(&rmod_masks.hyper, keysymMods.value(XKB_KEY_Hyper_R, -1));
718 while (*codes != XCB_NO_SYMBOL) {
719 if (*codes == which)
return true;
737 qWarning(
"Qt: failed to get modifier mapping");
742 static const xcb_keysym_t symbols[] = {
743 XKB_KEY_Alt_L, XKB_KEY_Meta_L, XKB_KEY_Mode_switch, XKB_KEY_Super_L, XKB_KEY_Super_R,
744 XKB_KEY_Hyper_L, XKB_KEY_Hyper_R
746 static const size_t numSymbols =
sizeof symbols /
sizeof *symbols;
749 xcb_keycode_t* modKeyCodes[numSymbols];
750 for (
size_t i = 0;
i < numSymbols; ++
i)
751 modKeyCodes[
i] = xcb_key_symbols_get_keycode(m_key_symbols, symbols[
i]);
753 xcb_keycode_t *modMap = xcb_get_modifier_mapping_keycodes(modMapReply.get());
754 const int modMapLength = xcb_get_modifier_mapping_keycodes_length(modMapReply.get());
789 for (
int i = 0;
i < modMapLength;
i++) {
790 if (modMap[
i] == XCB_NO_SYMBOL)
793 for (
size_t k = 0; k < numSymbols; k++) {
796 xcb_keysym_t sym = symbols[k];
800 map[sym] =
i / modMapReply->keycodes_per_modifier;
806 for (
size_t i = 0;
i < numSymbols; ++
i)
807 free(modKeyCodes[
i]);
817 if (rmod_masks.alt == rmod_masks.meta)
820 if (rmod_masks.meta == 0) {
822 rmod_masks.meta = rmod_masks.super;
823 if (rmod_masks.meta == 0) {
825 rmod_masks.meta = rmod_masks.hyper;
830 if (rmod_masks.meta && rmod_masks.meta == rmod_masks.super)
831 m_superAsMeta =
true;
832 if (rmod_masks.meta && rmod_masks.meta == rmod_masks.hyper)
833 m_hyperAsMeta =
true;
844 if (!targetWindow || !
source)
855 sendEventState.reset(xkb_state_new(m_xkbKeymap.get()));
860 xkb_state_update_mask(sendEventState.get(), depressed, 0, 0, 0, 0,
lockedGroup(
state));
863 struct xkb_state *xkbState =
fromSendEvent ? sendEventState.get() : m_xkbState.get();
865 xcb_keysym_t sym = xkb_state_key_get_one_sym(xkbState, code);
875 if (m_isAutoRepeat && m_autoRepeatCode != code)
877 m_isAutoRepeat =
false;
879 m_isAutoRepeat =
false;
883 if (
type == XCB_KEY_PRESS) {
884 auto keyPress =
reinterpret_cast<xcb_key_press_event_t *
>(
event);
885 m_isAutoRepeat = keyPress->time ==
time && keyPress->detail == code;
887 m_autoRepeatCode = code;
893 bool filtered =
false;
896 event.setTimestamp(
time);
897 filtered = inputContext->filterEvent(&
event);
902#ifndef QT_NO_CONTEXTMENU
904 const QPoint globalPos =
window->screen()->handle()->cursor()->pos();
919 const xcb_generic_event_t *e =
reinterpret_cast<const xcb_generic_event_t *
>(
event);
920 return (e->response_type & 0x80) != 0;
char * data()
\macro QT_NO_CAST_FROM_BYTEARRAY
qsizetype size() const noexcept
Returns the number of bytes in this byte array.
const char * constData() const noexcept
Returns a pointer to the const data stored in the byte array.
static QByteArray number(int, int base=10)
Returns a byte-array representing the whole number n as text.
Type
This enum type defines the valid event types in Qt.
static QPlatformIntegration * platformIntegration()
The QKeyEvent class describes a key event.
\inmodule QtCore\reentrant
\macro QT_RESTRICTED_CAST_FROM_ASCII
qsizetype size() const noexcept
Returns the number of characters in this string.
static void handleContextMenuEvent(QWindow *window, bool mouseTriggered, const QPoint &pos, const QPoint &globalPos, Qt::KeyboardModifiers modifiers)
static bool handleExtendedKeyEvent(QWindow *window, QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers, const QString &text=QString(), bool autorep=false, ushort count=1)
QByteArray atomName(xcb_atom_t atom)
const xcb_setup_t * setup() const
QXcbWindow * focusWindow() const
QXcbEventQueue * eventQueue() const
QXcbWindow * platformWindowFromId(xcb_window_t id)
static void queryPointer(QXcbConnection *c, QXcbVirtualDesktop **virtualDesktop, QPoint *pos, int *keybMask=nullptr)
xcb_generic_event_t * peek(Peeker &&peeker)
void handleKeyPressEvent(const xcb_key_press_event_t *event)
void handleKeyReleaseEvent(const xcb_key_release_event_t *event)
Qt::KeyboardModifiers queryKeyboardModifiers() const override
void resolveMaskConflicts()
void handleKeyEvent(xcb_window_t sourceWindow, QEvent::Type type, xcb_keycode_t code, quint16 state, xcb_timestamp_t time, bool fromSendEvent)
xkb_mod_mask_t xkbModMask(quint16 state)
void updateXKBState(xcb_xkb_state_notify_event_t *state)
QList< QKeyCombination > possibleKeyCombinations(const QKeyEvent *event) const override
void updateVModToRModMapping()
Qt::KeyboardModifiers translateModifiers(int s) const
QXcbKeyboard(QXcbConnection *connection)
void updateXKBStateFromCore(quint16 state)
void handleStateChanges(xkb_state_component changedComponents)
KeysymModifierMap keysymsToModifiers()
void updateXKBStateFromXI(void *modInfo, void *groupInfo)
void updateModifiers(const KeysymModifierMap &keysymMods)
struct xkb_keymap * keymapFromCore(const KeysymModifierMap &keysymMods)
QXcbConnection * connection() const
xcb_connection_t * xcb_connection() const
void updateNetWmUserTime(xcb_timestamp_t timestamp)
static void xkbcommon_XConvertCase(xkb_keysym_t sym, xkb_keysym_t *lower, xkb_keysym_t *upper)
static QList< QKeyCombination > possibleKeyCombinations(xkb_state *state, const QKeyEvent *event, bool superAsMeta=false, bool hyperAsMeta=false)
static QString lookupString(struct xkb_state *state, xkb_keycode_t code)
static void verifyHasLatinLayout(xkb_keymap *keymap)
std::unique_ptr< struct xkb_state, XKBStateDeleter > ScopedXKBState
static void setXkbContext(QPlatformInputContext *inputContext, struct xkb_context *context)
static bool isKeypad(xkb_keysym_t sym)
static int keysymToQtKey(xkb_keysym_t keysym, Qt::KeyboardModifiers modifiers)
EGLImageKHR int int EGLuint64KHR * modifiers
QMap< QString, QString > map
[6]
Combined button and popup list for selecting options.
Q_CORE_EXPORT int qstrcmp(const char *str1, const char *str2)
DBusConnection const char DBusError * error
DBusConnection * connection
typedef QByteArray(EGLAPIENTRYP PFNQGSGETDISPLAYSPROC)()
#define qCWarning(category,...)
#define qCDebug(category,...)
GLsizei GLsizei GLchar * groupString
GLenum GLenum GLsizei count
GLint GLint GLint GLint GLint GLint GLint GLbitfield mask
GLsizei GLsizei GLchar * source
#define XKB_MOD_NAME_SHIFT
#define XKB_MOD_NAME_CTRL
#define Q_XCB_REPLY(call,...)
static xcb_keysym_t getUnshiftedXKey(xcb_keysym_t unshifted, xcb_keysym_t shifted)
static xkb_layout_index_t lockedGroup(quint16 state)
static void applyModifier(uint *mask, int modifierBit)
static bool keycodes_contains(xcb_keycode_t *codes, xcb_keycode_t which)
static bool fromSendEvent(const void *event)
static QByteArray symbolsGroupString(const xcb_keysym_t *symbols, int count)
selection select(topLeft, bottomRight)