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");
}
static void
process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
{
xkb_keycode_t keycode;
struct xkb_keymap *keymap;
enum xkb_state_component changed;
if (type != EV_KEY)
return;
keycode = evdev_offset + code;
keymap = xkb_state_get_keymap(kbd->state);
if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
return;
if (value != KEY_STATE_RELEASE)
test_print_keycode_state(kbd->state, keycode);
if (value == KEY_STATE_RELEASE)
changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_UP);
else
changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
if (report_state_changes)
test_print_state_changes(changed);
}
static void uxkb_dev_repeat(struct uterm_input_dev *dev, unsigned int state)
{
struct xkb_keymap *keymap = xkb_state_get_keymap(dev->state);
unsigned int i;
int num_keysyms, ret;
const uint32_t *keysyms;
struct itimerspec spec;
if (dev->repeating && dev->repeat_event.keycode == dev->event.keycode) {
if (state == KEY_RELEASED) {
dev->repeating = false;
ev_timer_update(dev->repeat_timer, NULL);
}
return;
}
if (state == KEY_PRESSED &&
xkb_keymap_key_repeats(keymap, dev->event.keycode)) {
dev->repeat_event.keycode = dev->event.keycode;
dev->repeat_event.ascii = dev->event.ascii;
dev->repeat_event.mods = dev->event.mods;
dev->repeat_event.num_syms = dev->event.num_syms;
for (i = 0; i < dev->event.num_syms; ++i) {
dev->repeat_event.keysyms[i] = dev->event.keysyms[i];
dev->repeat_event.codepoints[i] =
dev->event.codepoints[i];
}
} else if (dev->repeating &&
!xkb_keymap_key_repeats(keymap, dev->event.keycode)) {
num_keysyms = xkb_state_key_get_syms(dev->state,
dev->repeat_event.keycode,
&keysyms);
if (num_keysyms <= 0)
return;
ret = uxkb_dev_fill_event(dev, &dev->repeat_event,
dev->repeat_event.keycode,
num_keysyms, keysyms);
if (ret)
return;
return;
} else {
return;
}
dev->repeating = true;
spec.it_interval.tv_sec = 0;
spec.it_interval.tv_nsec = dev->input->repeat_rate * 1000000;
spec.it_value.tv_sec = 0;
spec.it_value.tv_nsec = dev->input->repeat_delay * 1000000;
ev_timer_update(dev->repeat_timer, &spec);
}
static int8_t guess_ascii(struct xkb_state *state, uint32_t code, uint32_t n_syms, const uint32_t *syms) {
xkb_layout_index_t n_lo, lo;
xkb_level_index_t lv;
struct xkb_keymap *keymap;
const xkb_keysym_t *s;
int num;
if (n_syms == 1 && syms[0] < 128 && syms[0] > 0)
return syms[0];
keymap = xkb_state_get_keymap(state);
n_lo = xkb_keymap_num_layouts_for_key(keymap, code + KBDXKB_SHIFT);
for (lo = 0; lo < n_lo; ++lo) {
lv = xkb_state_key_get_level(state, code + KBDXKB_SHIFT, lo);
num = xkb_keymap_key_get_syms_by_level(keymap, code + KBDXKB_SHIFT, lo, lv, &s);
if (num == 1 && s[0] < 128 && s[0] > 0)
return s[0];
}
return -1;
}
void
clutter_seat_evdev_notify_key (ClutterSeatEvdev *seat,
ClutterInputDevice *device,
uint64_t time_us,
uint32_t key,
uint32_t state,
gboolean update_keys)
{
ClutterStage *stage;
ClutterEvent *event = NULL;
enum xkb_state_component changed_state;
if (state != AUTOREPEAT_VALUE)
{
/* Drop any repeated button press (for example from virtual devices. */
int count = update_button_count (seat, key, state);
if (state && count > 1)
return;
if (!state && count != 0)
return;
}
/* We can drop the event on the floor if no stage has been
* associated with the device yet. */
stage = _clutter_input_device_get_stage (device);
if (stage == NULL)
{
clutter_seat_evdev_clear_repeat_timer (seat);
return;
}
event = _clutter_key_event_new_from_evdev (device,
seat->core_keyboard,
stage,
seat->xkb,
seat->button_state,
us2ms (time_us), key, state);
_clutter_evdev_event_set_event_code (event, key);
/* We must be careful and not pass multiple releases to xkb, otherwise it gets
confused and locks the modifiers */
if (state != AUTOREPEAT_VALUE)
{
changed_state = xkb_state_update_key (seat->xkb,
event->key.hardware_keycode,
state ? XKB_KEY_DOWN : XKB_KEY_UP);
}
else
{
changed_state = 0;
clutter_event_set_flags (event, CLUTTER_EVENT_FLAG_REPEATED);
}
queue_event (event);
if (update_keys && (changed_state & XKB_STATE_LEDS))
{
ClutterBackend *backend;
backend = clutter_get_default_backend ();
g_signal_emit_by_name (clutter_backend_get_keymap (backend), "state-changed");
clutter_seat_evdev_sync_leds (seat);
}
if (state == 0 || /* key release */
!seat->repeat ||
!xkb_keymap_key_repeats (xkb_state_get_keymap (seat->xkb),
event->key.hardware_keycode))
{
clutter_seat_evdev_clear_repeat_timer (seat);
return;
}
if (state == 1) /* key press */
seat->repeat_count = 0;
seat->repeat_count += 1;
seat->repeat_key = key;
switch (seat->repeat_count)
{
case 1:
case 2:
{
guint32 interval;
clutter_seat_evdev_clear_repeat_timer (seat);
seat->repeat_device = g_object_ref (device);
if (seat->repeat_count == 1)
interval = seat->repeat_delay;
else
interval = seat->repeat_interval;
seat->repeat_timer =
clutter_threads_add_timeout_full (CLUTTER_PRIORITY_EVENTS,
interval,
keyboard_repeat,
seat,
NULL);
return;
}
default:
return;
}
}
static void
print_state(struct xkb_state *state)
{
struct xkb_keymap *keymap;
xkb_layout_index_t group;
xkb_mod_index_t mod;
xkb_led_index_t led;
group = xkb_state_serialize_layout(state, XKB_STATE_LAYOUT_EFFECTIVE);
mod = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
/* led = xkb_state_serialize_leds(state, XKB_STATE_LEDS); */
if (!group && !mod /* && !led */) {
fprintf(stderr, "\tno state\n");
return;
}
keymap = xkb_state_get_keymap(state);
for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
if (xkb_state_layout_index_is_active(state, group,
XKB_STATE_LAYOUT_EFFECTIVE |
XKB_STATE_LAYOUT_DEPRESSED |
XKB_STATE_LAYOUT_LATCHED |
XKB_STATE_LAYOUT_LOCKED) <= 0)
continue;
fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
xkb_keymap_layout_get_name(keymap, group),
group,
xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_EFFECTIVE) > 0 ?
"effective " : "",
xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_DEPRESSED) > 0 ?
"depressed " : "",
xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_LATCHED) > 0 ?
"latched " : "",
xkb_state_layout_index_is_active(state, group, XKB_STATE_LAYOUT_LOCKED) > 0 ?
"locked " : "");
}
for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
if (xkb_state_mod_index_is_active(state, mod,
XKB_STATE_MODS_EFFECTIVE |
XKB_STATE_MODS_DEPRESSED |
XKB_STATE_MODS_LATCHED |
XKB_STATE_MODS_LOCKED) <= 0)
continue;
fprintf(stderr, "\tmod %s (%d): %s%s%s%s\n",
xkb_keymap_mod_get_name(keymap, mod),
mod,
xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_EFFECTIVE) > 0 ?
"effective " : "",
xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_DEPRESSED) > 0 ?
"depressed " : "",
xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_LATCHED) > 0 ?
"latched " : "",
xkb_state_mod_index_is_active(state, mod, XKB_STATE_MODS_LOCKED) > 0 ?
"locked " : "");
}
for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
if (xkb_state_led_index_is_active(state, led) <= 0)
continue;
fprintf(stderr, "\tled %s (%d): active\n",
xkb_keymap_led_get_name(keymap, led),
led);
}
}
