static void print_keycode(struct keyboard *kbd, xkb_keycode_t keycode) { unsigned int i; struct xkb_keymap *keymap; struct xkb_state *state; const xkb_keysym_t *syms; unsigned int nsyms; char s[16]; uint32_t unicode; xkb_layout_index_t layout; xkb_mod_index_t mod; xkb_led_index_t led; state = kbd->state; keymap = xkb_state_get_keymap(state); nsyms = xkb_state_key_get_syms(state, keycode, &syms); if (nsyms <= 0) return; printf("keysyms [ "); for (i = 0; i < nsyms; i++) { xkb_keysym_get_name(syms[i], s, sizeof(s)); printf("%-*s ", (int)sizeof(s), s); } printf("] "); /* * Only do this if wchar_t is UCS-4, so we can be lazy and print * with %lc. */ #ifdef __STDC_ISO_10646__ printf("unicode [ "); for (i = 0; i < nsyms; i++) { unicode = xkb_keysym_to_utf32(syms[i]); printf("%lc ", (int)(unicode ? unicode : L' ')); } printf("] "); #endif layout = xkb_state_key_get_layout(state, keycode); printf("layout [ %s (%d) ] ", xkb_keymap_layout_get_name(keymap, layout), layout); printf("level [ %d ] ", xkb_state_key_get_level(state, keycode, layout)); printf("mods [ "); for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) { if (xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_EFFECTIVE) <= 0) continue; if (xkb_state_mod_index_is_consumed(state, keycode, mod)) printf("-%s ", xkb_keymap_mod_get_name(keymap, mod)); else printf("%s ", xkb_keymap_mod_get_name(keymap, mod)); } printf("] "); printf("leds [ "); for (led = 0; led < xkb_keymap_num_leds(keymap); led++) { if (xkb_state_led_index_is_active(state, led) <= 0) continue; printf("%s ", xkb_keymap_led_get_name(keymap, led)); } printf("] "); printf("\n"); }
/* FIXME: Don't handle composed and dead-keys properly. * Waiting for support in libxkbcommon ... */ int handle_xkb(int code, int value) { unsigned i; const xkb_keysym_t *syms = NULL; unsigned num_syms = 0; uint16_t mod = 0; /* Convert Linux evdev to X11 (xkbcommon docs say so at least ...) */ int xk_code = code + 8; if (!xkb_state) return -1; if (value == 2) /* Repeat, release first explicitly. */ xkb_state_update_key(xkb_state, xk_code, XKB_KEY_UP); if (value) num_syms = xkb_state_key_get_syms(xkb_state, xk_code, &syms); if (value > 0) xkb_state_update_key(xkb_state, xk_code, XKB_KEY_DOWN); else xkb_state_update_key(xkb_state, xk_code, XKB_KEY_UP); if (!syms) return -1; /* Build mod state. */ for (i = 0; i < MOD_MAP_SIZE; i++) { xkb_mod_index_t *map_idx = (xkb_mod_index_t*)&mod_map_idx[i]; uint16_t *map_bit = (uint16_t *)&mod_map_bit[i]; if (*map_idx != XKB_MOD_INVALID) mod |= xkb_state_mod_index_is_active( xkb_state, *map_idx, (enum xkb_state_component) ((XKB_STATE_MODS_EFFECTIVE) > 0)) ? *map_bit : 0; } input_keyboard_event(value, input_keymaps_translate_keysym_to_rk(code), num_syms ? xkb_keysym_to_utf32(syms[0]) : 0, mod, RETRO_DEVICE_KEYBOARD); for (i = 1; i < num_syms; i++) input_keyboard_event(value, RETROK_UNKNOWN, xkb_keysym_to_utf32(syms[i]), mod, RETRO_DEVICE_KEYBOARD); return 0; }
static int uxkb_dev_fill_event(struct uterm_input_dev *dev, struct uterm_input_event *ev, xkb_keycode_t code, int num_syms, const xkb_keysym_t *syms) { int ret, i; ret = uxkb_dev_resize_event(dev, num_syms); if (ret) return ret; ev->keycode = code; ev->ascii = shl_get_ascii(dev->state, code, syms, num_syms); ev->mods = shl_get_xkb_mods(dev->state); ev->num_syms = num_syms; memcpy(ev->keysyms, syms, sizeof(uint32_t) * num_syms); for (i = 0; i < num_syms; ++i) { ev->codepoints[i] = xkb_keysym_to_utf32(syms[i]); if (!ev->codepoints[i]) ev->codepoints[i] = UTERM_INPUT_INVALID; } return 0; }
void EglFSWaylandInput::processKeyEvent(QEvent::Type type, quint32 time, quint32 key) { EglFSWaylandWindow *window = EglFSWaylandWindow::fromSurface( m_seat->keyboard()->focusSurface()); if (!createDefaultKeymap()) return; quint32 code = key + 8; QString text; const xkb_keysym_t sym = xkb_state_key_get_one_sym(m_xkbState, code); quint32 utf32 = xkb_keysym_to_utf32(sym); if (utf32) text = QString::fromUcs4(&utf32, 1); int qtKey = EglFSXkb::keysymToQtKey(sym, m_modifiers, text); QWindowSystemInterface::handleExtendedKeyEvent(window ? window->window() : Q_NULLPTR, time, type, qtKey, m_modifiers, code, sym, m_nativeModifiers, text); if (type == QEvent::KeyPress && xkb_keymap_key_repeats(m_xkbKeymap, code)) { m_repeatKey = qtKey; m_repeatCode = code; m_repeatTime = time; m_repeatText = text; m_repeatSym = sym; m_repeatTimer.setInterval(m_seat->keyboard()->repeatRate()); m_repeatTimer.start(); } else if (m_repeatCode == code) { m_repeatTimer.stop(); } }
static int keyboard_fill(idev_keyboard *k, idev_data *dst, bool resync, uint16_t code, uint32_t value, uint32_t n_syms, const uint32_t *keysyms) { idev_data_keyboard *kev; uint32_t i; int r; assert(dst == &k->evdata || dst == &k->repdata); r = keyboard_resize_bufs(k, n_syms); if (r < 0) return r; dst->type = IDEV_DATA_KEYBOARD; dst->resync = resync; kev = &dst->keyboard; kev->ascii = guess_ascii(k->xkb_state, code, n_syms, keysyms); kev->value = value; kev->keycode = code; kev->mods = 0; kev->consumed_mods = 0; kev->n_syms = n_syms; memcpy(kev->keysyms, keysyms, sizeof(*keysyms) * n_syms); for (i = 0; i < n_syms; ++i) { kev->codepoints[i] = xkb_keysym_to_utf32(keysyms[i]); if (!kev->codepoints[i]) kev->codepoints[i] = 0xffffffffUL; } for (i = 0; i < IDEV_KBDMOD_CNT; ++i) { if (k->kbdmap->modmap[i] == XKB_MOD_INVALID) continue; r = xkb_state_mod_index_is_active(k->xkb_state, k->kbdmap->modmap[i], XKB_STATE_MODS_EFFECTIVE); if (r > 0) kev->mods |= 1 << i; r = xkb_state_mod_index_is_consumed(k->xkb_state, code + KBDXKB_SHIFT, k->kbdmap->modmap[i]); if (r > 0) kev->consumed_mods |= 1 << i; } return 0; }
static void handleKeyEvent(WaylandDisplay::SeatData& seatData, uint32_t key, uint32_t state, uint32_t time) { auto& xkb = seatData.xkb; uint32_t keysym = xkb_state_key_get_one_sym(xkb.state, key); uint32_t unicode = xkb_state_key_get_utf32(xkb.state, key); if (state == WL_KEYBOARD_KEY_STATE_PRESSED && xkb_compose_state_feed(xkb.composeState, keysym) == XKB_COMPOSE_FEED_ACCEPTED && xkb_compose_state_get_status(xkb.composeState) == XKB_COMPOSE_COMPOSED) { keysym = xkb_compose_state_get_one_sym(xkb.composeState); unicode = xkb_keysym_to_utf32(keysym); } if (seatData.keyboard.target.first) seatData.keyboard.target.second->handleKeyboardEvent({ time, keysym, unicode, !!state, xkb.modifiers }); }