/*
* Loads the XKB keymap from the X11 server and feeds it to xkbcommon.
* Necessary so that we can properly let xkbcommon track the keyboard state and
* translate keypresses to utf-8.
*
*/
static bool load_keymap(void) {
if (xkb_context == NULL) {
if ((xkb_context = xkb_context_new(0)) == NULL) {
fprintf(stderr, "[i3lock] could not create xkbcommon context\n");
return false;
}
}
xkb_keymap_unref(xkb_keymap);
int32_t device_id = xkb_x11_get_core_keyboard_device_id(conn);
DEBUG("device = %d\n", device_id);
if ((xkb_keymap = xkb_x11_keymap_new_from_device(xkb_context, conn, device_id, 0)) == NULL) {
fprintf(stderr, "[i3lock] xkb_x11_keymap_new_from_device failed\n");
return false;
}
struct xkb_state *new_state =
xkb_x11_state_new_from_device(xkb_keymap, conn, device_id);
if (new_state == NULL) {
fprintf(stderr, "[i3lock] xkb_x11_state_new_from_device failed\n");
return false;
}
xkb_state_unref(xkb_state);
xkb_state = new_state;
return true;
}
static int keyboard_update_kbdmap(idev_keyboard *k) {
idev_device *d = &k->device;
struct xkb_state *state;
kbdmap *km;
int r;
assert(k);
km = k->kbdctx->kbdmap;
if (km == k->kbdmap)
return 0;
errno = 0;
state = xkb_state_new(km->xkb_keymap);
if (!state) {
r = errno > 0 ? -errno : -EFAULT;
goto error;
}
kbdmap_unref(k->kbdmap);
k->kbdmap = kbdmap_ref(km);
xkb_state_unref(k->xkb_state);
k->xkb_state = state;
/* TODO: On state-change, we should trigger a resync so the whole
* event-state is flushed into the new xkb-state. libevdev currently
* does not support that, though. */
return 0;
error:
return log_debug_errno(r, "idev-keyboard: %s/%s: cannot adopt new keymap: %m",
d->session->name, d->name);
}
static void
clutter_wayland_handle_keymap (void *data,
struct wl_keyboard *keyboard,
uint32_t format,
int32_t fd,
uint32_t size)
{
ClutterInputDeviceWayland *device = data;
struct xkb_context *ctx;
struct xkb_keymap *keymap;
char *map_str;
if (device->xkb)
{
xkb_state_unref (device->xkb);
device->xkb = NULL;
}
ctx = xkb_context_new (0);
if (!ctx)
{
close (fd);
return;
}
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
{
close (fd);
return;
}
map_str = mmap (NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map_str == MAP_FAILED)
{
close(fd);
return;
}
keymap = xkb_map_new_from_string (ctx,
map_str,
XKB_KEYMAP_FORMAT_TEXT_V1,
0);
xkb_context_unref (ctx);
munmap (map_str, size);
close (fd);
if (!keymap)
{
g_warning ("failed to compile keymap\n");
return;
}
device->xkb = xkb_state_new(keymap);
xkb_map_unref (keymap);
if (!device->xkb)
{
g_warning ("failed to create XKB state object\n");
return;
}
}
int
main(void)
{
struct xkb_context *context = test_get_context(0);
struct xkb_keymap *keymap;
assert(context);
/* Make sure these are allowed. */
xkb_context_unref(NULL);
xkb_keymap_unref(NULL);
xkb_state_unref(NULL);
keymap = test_compile_rules(context, "evdev", "pc104", "us,ru", NULL, "grp:menu_toggle");
assert(keymap);
test_update_key(keymap);
test_serialisation(keymap);
test_repeat(keymap);
test_consume(keymap);
test_range(keymap);
test_get_utf8_utf32(keymap);
test_ctrl_string_transformation(keymap);
xkb_keymap_unref(keymap);
keymap = test_compile_rules(context, "evdev", NULL, "ch", "fr", NULL);
assert(keymap);
test_caps_keysym_transformation(keymap);
xkb_keymap_unref(keymap);
xkb_context_unref(context);
}
static void keyboardHandleKeymap(void* data,
struct wl_keyboard* keyboard,
uint32_t format,
int fd,
uint32_t size)
{
struct xkb_keymap* keymap;
struct xkb_state* state;
char* mapStr;
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
{
close(fd);
return;
}
mapStr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (mapStr == MAP_FAILED) {
close(fd);
return;
}
keymap = xkb_map_new_from_string(_glfw.wl.xkb.context,
mapStr,
XKB_KEYMAP_FORMAT_TEXT_V1,
0);
munmap(mapStr, size);
close(fd);
if (!keymap)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to compile keymap");
return;
}
state = xkb_state_new(keymap);
if (!state)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB state");
xkb_map_unref(keymap);
return;
}
xkb_keymap_unref(_glfw.wl.xkb.keymap);
xkb_state_unref(_glfw.wl.xkb.state);
_glfw.wl.xkb.keymap = keymap;
_glfw.wl.xkb.state = state;
_glfw.wl.xkb.control_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Control");
_glfw.wl.xkb.alt_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
_glfw.wl.xkb.shift_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
_glfw.wl.xkb.super_mask =
1 << xkb_map_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
}
void EglFSWaylandInput::releaseKeymap()
{
if (m_xkbState)
xkb_state_unref(m_xkbState);
if (m_xkbKeymap)
xkb_map_unref(m_xkbKeymap);
if (m_xkbContext)
xkb_context_unref(m_xkbContext);
}
static void uxkb_dev_unref(struct kbd_dev *kbd)
{
if (!kbd || !kbd->ref || --kbd->ref)
return;
xkb_state_unref(kbd->uxkb.state);
kbd_desc_unref(kbd->desc);
free(kbd);
}
/*
* Loads the XKB keymap from the X11 server and feeds it to xkbcommon.
* Necessary so that we can properly let xkbcommon track the keyboard state and
* translate keypresses to utf-8.
*
* Ideally, xkbcommon would ship something like this itself, but as of now
* (version 0.2.0), it doesn’t.
*
*/
static bool load_keymap(void) {
bool ret = false;
XkbFileInfo result;
memset(&result, '\0', sizeof(result));
result.xkb = XkbGetKeyboard(display, XkbAllMapComponentsMask, XkbUseCoreKbd);
if (result.xkb == NULL) {
fprintf(stderr, "[i3lock] XKB: XkbGetKeyboard failed\n");
return false;
}
FILE *temp = tmpfile();
if (temp == NULL) {
fprintf(stderr, "[i3lock] could not create tempfile\n");
return false;
}
bool ok = XkbWriteXKBKeymap(temp, &result, false, false, NULL, NULL);
if (!ok) {
fprintf(stderr, "[i3lock] XkbWriteXKBKeymap failed\n");
goto out;
}
rewind(temp);
if (xkb_context == NULL) {
if ((xkb_context = xkb_context_new(0)) == NULL) {
fprintf(stderr, "[i3lock] could not create xkbcommon context\n");
goto out;
}
}
if (xkb_keymap != NULL)
xkb_keymap_unref(xkb_keymap);
if ((xkb_keymap = xkb_keymap_new_from_file(xkb_context, temp, XKB_KEYMAP_FORMAT_TEXT_V1, 0)) == NULL) {
fprintf(stderr, "[i3lock] xkb_keymap_new_from_file failed\n");
goto out;
}
struct xkb_state *new_state = xkb_state_new(xkb_keymap);
if (new_state == NULL) {
fprintf(stderr, "[i3lock] xkb_state_new failed\n");
goto out;
}
if (xkb_state != NULL)
xkb_state_unref(xkb_state);
xkb_state = new_state;
ret = true;
out:
XkbFreeKeyboard(result.xkb, XkbAllComponentsMask, true);
fclose(temp);
return ret;
}
static void
keyboard_free(struct keyboard *kbd)
{
if (!kbd)
return;
if (kbd->fd >= 0)
close(kbd->fd);
free(kbd->path);
xkb_state_unref(kbd->state);
free(kbd);
}
QLibInputKeyboard::~QLibInputKeyboard()
{
#ifndef QT_NO_XKBCOMMON_EVDEV
if (m_state)
xkb_state_unref(m_state);
if (m_keymap)
xkb_keymap_unref(m_keymap);
if (m_ctx)
xkb_context_unref(m_ctx);
#endif
}
static int
keyboard_new(struct dirent *ent, struct xkb_keymap *keymap,
struct keyboard **out)
{
int ret;
char *path;
int fd;
struct xkb_state *state;
struct keyboard *kbd;
ret = asprintf(&path, "/dev/input/%s", ent->d_name);
if (ret < 0)
return -ENOMEM;
fd = open(path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
if (fd < 0) {
ret = -errno;
goto err_path;
}
if (!is_keyboard(fd)) {
/* Dummy "skip this device" value. */
ret = -ENOTSUP;
goto err_fd;
}
state = xkb_state_new(keymap);
if (!state) {
fprintf(stderr, "Couldn't create xkb state for %s\n", path);
ret = -EFAULT;
goto err_fd;
}
kbd = calloc(1, sizeof(*kbd));
if (!kbd) {
ret = -ENOMEM;
goto err_state;
}
kbd->path = path;
kbd->fd = fd;
kbd->state = state;
*out = kbd;
return 0;
err_state:
xkb_state_unref(state);
err_fd:
close(fd);
err_path:
free(path);
return ret;
}
QWaylandKeyboardPrivate::~QWaylandKeyboardPrivate()
{
#ifndef QT_NO_WAYLAND_XKB
if (xkb_context) {
if (keymap_area)
munmap(keymap_area, keymap_size);
close(keymap_fd);
xkb_context_unref(xkb_context);
xkb_state_unref(xkb_state);
}
#endif
}
static void
test_serialisation(struct xkb_keymap *keymap)
{
struct xkb_state *state = xkb_state_new(keymap);
xkb_mod_mask_t base_mods;
xkb_mod_mask_t latched_mods;
xkb_mod_mask_t locked_mods;
xkb_mod_mask_t effective_mods;
xkb_mod_index_t caps, shift, ctrl;
xkb_layout_index_t base_group = 0;
xkb_layout_index_t latched_group = 0;
xkb_layout_index_t locked_group = 0;
assert(state);
caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
assert(caps != XKB_MOD_INVALID);
shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(shift != XKB_MOD_INVALID);
ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
assert(ctrl != XKB_MOD_INVALID);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
base_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
assert(base_mods == 0);
latched_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
assert(latched_mods == 0);
locked_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
assert(locked_mods == (1U << caps));
effective_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
assert(effective_mods == locked_mods);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
base_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_DEPRESSED);
assert(base_mods == (1U << shift));
latched_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LATCHED);
assert(latched_mods == 0);
locked_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_LOCKED);
assert(locked_mods == (1U << caps));
effective_mods = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
assert(effective_mods == (base_mods | locked_mods));
base_mods |= (1U << ctrl);
xkb_state_update_mask(state, base_mods, latched_mods, locked_mods,
base_group, latched_group, locked_group);
assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_DEPRESSED) > 0);
assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
xkb_state_unref(state);
}
/*
* Try closing the input device(s)
*/
void fgPlatformCloseInputDevices( void )
{
if( fgDisplay.pDisplay.touch )
wl_touch_destroy( fgDisplay.pDisplay.touch );
if( fgDisplay.pDisplay.pointer )
wl_pointer_destroy( fgDisplay.pDisplay.pointer );
if( fgDisplay.pDisplay.keyboard )
wl_keyboard_destroy( fgDisplay.pDisplay.keyboard );
if( fgDisplay.pDisplay.xkb_state )
xkb_state_unref( fgDisplay.pDisplay.xkb_state );
if( fgDisplay.pDisplay.xkb_context )
xkb_context_unref( fgDisplay.pDisplay.xkb_context );
}
void
xrtb_keyboard_fini(struct xcb_rutabaga *xrtb)
{
assert(xrtb->xkb_ctx);
xkb_context_unref(xrtb->xkb_ctx);
if (xrtb->xkb_keymap)
xkb_keymap_unref(xrtb->xkb_keymap);
if (xrtb->xkb_state)
xkb_state_unref(xrtb->xkb_state);
}
/**
* Process X11 events in the main-loop (gui-thread) of the application.
*/
static gboolean main_loop_x11_event_handler ( xcb_generic_event_t *ev, G_GNUC_UNUSED gpointer data )
{
if ( ev == NULL ) {
int status = xcb_connection_has_error ( xcb->connection );
fprintf ( stderr, "The XCB connection to X server had a fatal error: %d\n", status );
g_main_loop_quit ( main_loop );
return G_SOURCE_REMOVE;
}
uint8_t type = ev->response_type & ~0x80;
if ( type == xkb.first_event ) {
switch ( ev->pad0 )
{
case XCB_XKB_MAP_NOTIFY:
xkb_state_unref ( xkb.state );
xkb_keymap_unref ( xkb.keymap );
xkb.keymap = xkb_x11_keymap_new_from_device ( xkb.context, xcb->connection, xkb.device_id, 0 );
xkb.state = xkb_x11_state_new_from_device ( xkb.keymap, xcb->connection, xkb.device_id );
break;
case XCB_XKB_STATE_NOTIFY:
{
xcb_xkb_state_notify_event_t *ksne = (xcb_xkb_state_notify_event_t *) ev;
xkb_state_update_mask ( xkb.state,
ksne->baseMods,
ksne->latchedMods,
ksne->lockedMods,
ksne->baseGroup,
ksne->latchedGroup,
ksne->lockedGroup );
break;
}
}
return G_SOURCE_CONTINUE;
}
RofiViewState *state = rofi_view_get_active ();
if ( xcb->sndisplay != NULL ) {
sn_xcb_display_process_event ( xcb->sndisplay, ev );
}
if ( state != NULL ) {
rofi_view_itterrate ( state, ev, &xkb );
if ( rofi_view_get_completed ( state ) ) {
// This menu is done.
rofi_view_finalize ( state );
// cleanup
if ( rofi_view_get_active () == NULL ) {
teardown ( pfd );
g_main_loop_quit ( main_loop );
}
}
}
return G_SOURCE_CONTINUE;
}
static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
uint32_t format, int fd, uint32_t size)
{
UwacSeat *input = data;
struct xkb_keymap *keymap;
struct xkb_state *state;
char *map_str;
if (!data) {
close(fd);
return;
}
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
return;
}
map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map_str == MAP_FAILED) {
close(fd);
return;
}
keymap = xkb_keymap_new_from_string(input->xkb_context, map_str, XKB_KEYMAP_FORMAT_TEXT_V1, 0);
munmap(map_str, size);
close(fd);
if (!keymap) {
assert(uwacErrorHandler(input->display, UWAC_ERROR_INTERNAL, "failed to compile keymap\n"));
return;
}
state = xkb_state_new(keymap);
if (!state) {
assert(uwacErrorHandler(input->display, UWAC_ERROR_NOMEMORY, "failed to create XKB state\n"));
xkb_keymap_unref(keymap);
return;
}
xkb_keymap_unref(input->xkb.keymap);
xkb_state_unref(input->xkb.state);
input->xkb.keymap = keymap;
input->xkb.state = state;
input->xkb.control_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Control");
input->xkb.alt_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Mod1");
input->xkb.shift_mask = 1 << xkb_keymap_mod_get_index(input->xkb.keymap, "Shift");
}
static void keyboard_free(idev_device *d) {
idev_keyboard *k = keyboard_from_device(d);
xkb_compose_state_unref(k->xkb_compose);
xkb_state_unref(k->xkb_state);
free(k->repdata.keyboard.codepoints);
free(k->repdata.keyboard.keysyms);
free(k->evdata.keyboard.codepoints);
free(k->evdata.keyboard.keysyms);
free(k->compose_res);
k->repeat_timer = sd_event_source_unref(k->repeat_timer);
k->kbdtbl = kbdtbl_unref(k->kbdtbl);
k->kbdmap = kbdmap_unref(k->kbdmap);
k->kbdctx = kbdctx_unref(k->kbdctx);
free(k);
}
WaylandDisplay::~WaylandDisplay()
{
if (m_eventSource)
g_source_unref(m_eventSource);
m_eventSource = nullptr;
if (m_interfaces.compositor)
wl_compositor_destroy(m_interfaces.compositor);
if (m_interfaces.data_device_manager)
wl_data_device_manager_destroy(m_interfaces.data_device_manager);
if (m_interfaces.drm)
wl_drm_destroy(m_interfaces.drm);
if (m_interfaces.seat)
wl_seat_destroy(m_interfaces.seat);
if (m_interfaces.xdg)
xdg_shell_destroy(m_interfaces.xdg);
if (m_interfaces.ivi_application)
ivi_application_destroy(m_interfaces.ivi_application);
m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
if (m_registry)
wl_registry_destroy(m_registry);
m_registry = nullptr;
if (m_display)
wl_display_disconnect(m_display);
m_display = nullptr;
if (m_seatData.pointer.object)
wl_pointer_destroy(m_seatData.pointer.object);
if (m_seatData.keyboard.object)
wl_keyboard_destroy(m_seatData.keyboard.object);
if (m_seatData.touch.object)
wl_touch_destroy(m_seatData.touch.object);
if (m_seatData.xkb.context)
xkb_context_unref(m_seatData.xkb.context);
if (m_seatData.xkb.keymap)
xkb_keymap_unref(m_seatData.xkb.keymap);
if (m_seatData.xkb.state)
xkb_state_unref(m_seatData.xkb.state);
if (m_seatData.xkb.composeTable)
xkb_compose_table_unref(m_seatData.xkb.composeTable);
if (m_seatData.xkb.composeState)
xkb_compose_state_unref(m_seatData.xkb.composeState);
if (m_seatData.repeatData.eventSource)
g_source_remove(m_seatData.repeatData.eventSource);
m_seatData = SeatData{ };
}
static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard,
uint32_t format, int fd, uint32_t size) {
// Keyboard errors are abort-worthy because you wouldn't be able to unlock your screen otherwise.
struct registry *registry = data;
if (!data) {
close(fd);
return;
}
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
sway_abort("Unknown keymap format %d, aborting", format);
}
char *map_str = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map_str == MAP_FAILED) {
close(fd);
sway_abort("Unable to initialized shared keyboard memory, aborting");
}
struct xkb_keymap *keymap = xkb_keymap_new_from_string(registry->input->xkb.context,
map_str, XKB_KEYMAP_FORMAT_TEXT_V1, 0);
munmap(map_str, size);
close(fd);
if (!keymap) {
sway_abort("Failed to compile keymap, aborting");
}
struct xkb_state *state = xkb_state_new(keymap);
if (!state) {
xkb_keymap_unref(keymap);
sway_abort("Failed to create xkb state, aborting");
}
xkb_keymap_unref(registry->input->xkb.keymap);
xkb_state_unref(registry->input->xkb.state);
registry->input->xkb.keymap = keymap;
registry->input->xkb.state = state;
int i;
for (i = 0; i < MASK_LAST; ++i) {
registry->input->xkb.masks[i] = 1 << xkb_keymap_mod_get_index(registry->input->xkb.keymap, XKB_MASK_NAMES[i]);
}
}
int
xrtb_keyboard_reload(struct xcb_rutabaga *xrtb)
{
struct xkb_keymap *new_keymap;
int32_t device_id;
assert(xrtb->xkb_ctx);
device_id = xkb_x11_get_core_keyboard_device_id(xrtb->xcb_conn);
if (device_id == -1)
goto err_get_kbd_device;
if (!(new_keymap = xkb_x11_keymap_new_from_device(xrtb->xkb_ctx,
xrtb->xcb_conn, device_id, XKB_KEYMAP_COMPILE_NO_FLAGS)))
goto err_new_keymap;
if (xrtb->xkb_keymap)
xkb_keymap_unref(xrtb->xkb_keymap);
xrtb->xkb_keymap = new_keymap;
if (xrtb->xkb_state)
xkb_state_unref(xrtb->xkb_state);
if (!(xrtb->xkb_state = xkb_x11_state_new_from_device(new_keymap,
xrtb->xcb_conn, device_id)))
goto err_new_state;
#define CACHE_MOD_INDEX(name, constant) \
xrtb->mod_indices.name = xkb_keymap_mod_get_index(new_keymap, constant)
CACHE_MOD_INDEX(shift, XKB_MOD_NAME_SHIFT);
CACHE_MOD_INDEX(ctrl, XKB_MOD_NAME_CTRL);
CACHE_MOD_INDEX(alt, XKB_MOD_NAME_ALT);
CACHE_MOD_INDEX(super, XKB_MOD_NAME_LOGO);
#undef CACHE_MOD_INDEX
return 0;
err_new_state:
xkb_keymap_unref(xrtb->xkb_keymap);
xrtb->xkb_keymap = NULL;
err_new_keymap:
err_get_kbd_device:
return -1;
}
static void
test_ctrl_string_transformation(struct xkb_keymap *keymap)
{
char buf[256];
struct xkb_state *state = xkb_state_new(keymap);
xkb_mod_index_t ctrl;
assert(state);
/* See xkb_state_key_get_utf8() for what's this all about. */
ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
assert(ctrl != XKB_MOD_INVALID);
/* First without. */
TEST_KEY(KEY_A, "a", 0x61);
TEST_KEY(KEY_B, "b", 0x62);
TEST_KEY(KEY_C, "c", 0x63);
TEST_KEY(KEY_ESC, "\x1B", 0x1B);
TEST_KEY(KEY_1, "1", 0x31);
/* And with. */
xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
TEST_KEY(KEY_A, "\x01", 0x01);
TEST_KEY(KEY_B, "\x02", 0x02);
TEST_KEY(KEY_C, "\x03", 0x03);
TEST_KEY(KEY_ESC, "\x1B", 0x1B);
TEST_KEY(KEY_1, "1", 0x31);
xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
/* Switch to ru layout */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_key_get_layout(state, KEY_A + 8) == 1);
/* Non ASCII. */
xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(xkb_state_mod_index_is_active(state, ctrl, XKB_STATE_MODS_EFFECTIVE) > 0);
TEST_KEY(KEY_A, "\x01", 0x01);
TEST_KEY(KEY_B, "\x02", 0x02);
xkb_state_update_key(state, KEY_RIGHTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
xkb_state_unref(state);
}
/*
* Keyboard section
*/
static void fghKeyboardKeymap( void* data, struct wl_keyboard* keyboard,
uint32_t format, int fd, uint32_t size )
{
SFG_PlatformDisplay* pDisplay = data;
char* keymap_str;
struct xkb_keymap* keymap;
keymap_str = mmap( NULL, size, PROT_READ, MAP_SHARED, fd, 0 );
keymap = xkb_keymap_new_from_string( pDisplay->xkb_context,
keymap_str,
XKB_KEYMAP_FORMAT_TEXT_V1,
0 );
munmap( keymap_str, size );
if( pDisplay->xkb_state )
xkb_state_unref( pDisplay->xkb_state );
pDisplay->xkb_state = xkb_state_new( keymap );
}
void free_xkb(void)
{
if (mod_map_idx)
free(mod_map_idx);
if (mod_map_bit)
free(mod_map_bit);
if (xkb_map)
xkb_keymap_unref(xkb_map);
if (xkb_ctx)
xkb_context_unref(xkb_ctx);
if (xkb_state)
xkb_state_unref(xkb_state);
mod_map_idx = NULL;
mod_map_bit = NULL;
xkb_map = NULL;
xkb_ctx = NULL;
xkb_state = NULL;
}
/*
* Call this when we regain control of the keyboard after losing it.
* We don't reset the locked group, this should survive a VT switch, etc. The
* locked modifiers are reset according to the keyboard LEDs.
*/
static void uxkb_dev_reset(struct kbd_dev *kbd, const unsigned long *ledbits)
{
unsigned int i;
struct xkb_state *state;
static const struct {
int led;
const char *name;
} led_names[] = {
{ LED_NUML, XKB_LED_NAME_NUM },
{ LED_CAPSL, XKB_LED_NAME_CAPS },
{ LED_SCROLLL, XKB_LED_NAME_SCROLL },
};
if (!kbd)
return;
/* TODO: Urghs, while the input device was closed we might have missed
* some events that affect internal state. As xkbcommon does not provide
* a way to reset the internal state, we simply recreate the state. This
* should have the same effect.
* It also has a bug that if the CTRL-Release event is skipped, then
* every further release will never perform a _real_ release. Kind of
* buggy so we should fix it upstream. */
state = xkb_state_new(kbd->desc->uxkb.keymap);
if (!state) {
log_warning("cannot recreate xkb-state");
return;
}
xkb_state_unref(kbd->uxkb.state);
kbd->uxkb.state = state;
for (i = 0; i < sizeof(led_names) / sizeof(*led_names); i++) {
if (!input_bit_is_set(ledbits, led_names[i].led))
continue;
/*
* TODO: Add support in xkbcommon for setting the led state,
* and updating the modifier state accordingly. E.g., something
* like this:
* xkb_state_led_name_set_active(state, led_names[i].led);
*/
}
}
static void udev_input_free(void *data)
{
unsigned i;
udev_input_t *udev = (udev_input_t*)data;
if (!data || !udev)
return;
if (udev->joypad)
udev->joypad->destroy();
if (udev->epfd >= 0)
close(udev->epfd);
for (i = 0; i < udev->num_devices; i++)
{
close(udev->devices[i]->fd);
free(udev->devices[i]);
}
free(udev->devices);
if (udev->monitor)
udev_monitor_unref(udev->monitor);
if (udev->udev)
udev_unref(udev->udev);
#ifdef HAVE_XKBCOMMON
if (udev->mod_map_idx)
free(udev->mod_map_idx);
if (udev->mod_map_bit)
free(udev->mod_map_bit);
if (udev->xkb_map)
xkb_keymap_unref(udev->xkb_map);
if (udev->xkb_ctx)
xkb_context_unref(udev->xkb_ctx);
if (udev->xkb_state)
xkb_state_unref(udev->xkb_state);
#endif
free(udev);
}
/*
* Call this when we regain control of the keyboard after losing it.
* We don't reset the locked group, this should survive a VT switch, etc.
*/
void uxkb_dev_reset(struct uterm_input_dev *dev)
{
struct xkb_state *state;
/* TODO: Urghs, while the input device was closed we might have missed
* some events that affect internal state. As xkbcommon does not provide
* a way to reset the internal state, we simply recreate the state. This
* should have the same effect.
* It also has a bug that if the CTRL-Release event is skipped, then
* every further release will never perform a _real_ release. Kind of
* buggy so we should fix it upstream. */
state = xkb_state_new(dev->input->keymap);
if (!state) {
log_warning("cannot recreate xkb-state");
return;
}
xkb_state_unref(dev->state);
dev->state = state;
uxkb_dev_update_keyboard_leds(dev);
}
int
main(void)
{
struct xkb_context *ctx;
struct xkb_keymap *keymap;
struct xkb_state *state;
struct bench bench;
char *elapsed;
ctx = test_get_context(0);
assert(ctx);
keymap = test_compile_rules(ctx, "evdev", "pc104", "us,ru,il,de",
",,,neo", "grp:menu_toggle");
assert(keymap);
state = xkb_state_new(keymap);
assert(state);
xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_CRITICAL);
xkb_context_set_log_verbosity(ctx, 0);
srand(time(NULL));
bench_start(&bench);
bench_key_proc(state);
bench_stop(&bench);
elapsed = bench_elapsed_str(&bench);
fprintf(stderr, "ran %d iterations in %ss\n",
BENCHMARK_ITERATIONS, elapsed);
free(elapsed);
xkb_state_unref(state);
xkb_keymap_unref(keymap);
xkb_context_unref(ctx);
return 0;
}
void _glfwPlatformTerminate(void)
{
_glfwTerminateEGL();
_glfwTerminateJoysticksLinux();
_glfwTerminateThreadLocalStoragePOSIX();
xkb_keymap_unref(_glfw.wl.xkb.keymap);
xkb_state_unref(_glfw.wl.xkb.state);
xkb_context_unref(_glfw.wl.xkb.context);
if (_glfw.wl.cursorTheme)
wl_cursor_theme_destroy(_glfw.wl.cursorTheme);
if (_glfw.wl.cursorSurface)
wl_surface_destroy(_glfw.wl.cursorSurface);
if (_glfw.wl.compositor)
wl_compositor_destroy(_glfw.wl.compositor);
if (_glfw.wl.shm)
wl_shm_destroy(_glfw.wl.shm);
if (_glfw.wl.shell)
wl_shell_destroy(_glfw.wl.shell);
if (_glfw.wl.pointer)
wl_pointer_destroy(_glfw.wl.pointer);
if (_glfw.wl.keyboard)
wl_keyboard_destroy(_glfw.wl.keyboard);
if (_glfw.wl.seat)
wl_seat_destroy(_glfw.wl.seat);
if (_glfw.wl.relativePointerManager)
zwp_relative_pointer_manager_v1_destroy(_glfw.wl.relativePointerManager);
if (_glfw.wl.pointerConstraints)
zwp_pointer_constraints_v1_destroy(_glfw.wl.pointerConstraints);
if (_glfw.wl.registry)
wl_registry_destroy(_glfw.wl.registry);
if (_glfw.wl.display)
{
wl_display_flush(_glfw.wl.display);
wl_display_disconnect(_glfw.wl.display);
}
}
void
clutter_seat_evdev_free (ClutterSeatEvdev *seat)
{
GSList *iter;
for (iter = seat->devices; iter; iter = g_slist_next (iter))
{
ClutterInputDevice *device = iter->data;
g_object_unref (device);
}
g_slist_free (seat->devices);
g_free (seat->touch_states);
xkb_state_unref (seat->xkb);
clutter_seat_evdev_clear_repeat_timer (seat);
if (seat->libinput_seat)
libinput_seat_unref (seat->libinput_seat);
g_free (seat);
}
