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 });
}
