unsigned int freerdp_kbd_init(void* dpy, unsigned int keyboard_layout_id)
{
memset(x_keycode_to_rdp_scancode, 0, sizeof(x_keycode_to_rdp_scancode));
memset(rdp_scancode_to_x_keycode, '\0', sizeof(rdp_scancode_to_x_keycode));
#ifdef WITH_XKBFILE
if (!init_xkb(dpy))
{
DEBUG_KBD("Error initializing xkb");
return 0;
}
if (keyboard_layout_id == 0)
{
keyboard_layout_id = detect_keyboard_layout_from_xkb(dpy);
DEBUG_KBD("detect_keyboard_layout_from_xkb: %X", keyboard_layout_id);
}
init_keycodes_from_xkb(dpy, x_keycode_to_rdp_scancode, rdp_scancode_to_x_keycode);
#else
int vkcode;
int keycode;
char xkbfile[256];
KeycodeToVkcode keycodeToVkcode;
if (keyboard_layout_id == 0)
keyboard_layout_id = detect_keyboard(dpy, keyboard_layout_id, xkbfile, sizeof(xkbfile));
DEBUG_KBD("Using keyboard layout 0x%X with xkb name %s and xkbfile %s",
keyboard_layout_id, get_layout_name(keyboard_layout_id), xkbfile);
load_keyboard_map(keycodeToVkcode, xkbfile);
for (keycode = 0; keycode < 256; keycode++)
{
vkcode = keycodeToVkcode[keycode];
DEBUG_KBD("X keycode %3d VK %3d %-19s-> RDP scancode %d/%d",
keycode, vkcode, virtualKeyboard[vkcode].name,
virtualKeyboard[vkcode].extended, virtualKeyboard[vkcode].scancode);
x_keycode_to_rdp_scancode[keycode].keycode = virtualKeyboard[vkcode].scancode;
x_keycode_to_rdp_scancode[keycode].extended = virtualKeyboard[vkcode].extended;
x_keycode_to_rdp_scancode[keycode].keyname = virtualKeyboard[vkcode].name;
if (x_keycode_to_rdp_scancode[keycode].extended)
rdp_scancode_to_x_keycode[virtualKeyboard[vkcode].scancode][1] = keycode;
else
rdp_scancode_to_x_keycode[virtualKeyboard[vkcode].scancode][0] = keycode;
}
#endif
return keyboard_layout_id;
}
static void keyboard_handle_keymap(void* data,
struct wl_keyboard* keyboard,
uint32_t format,
int fd,
uint32_t size)
{
(void)data;
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
{
close(fd);
return;
}
#ifdef HAVE_XKBCOMMON
if (init_xkb(fd, size) < 0)
RARCH_ERR("[Wayland]: Failed to init keymap.\n");
#endif
close(fd);
RARCH_LOG("[Wayland]: Loaded keymap.\n");
}
struct display *
display_create(int *argc, char **argv[], const GOptionEntry *option_entries)
{
struct display *d;
GOptionContext *context;
GOptionGroup *xkb_option_group;
GError *error;
g_type_init();
context = g_option_context_new(NULL);
if (option_entries)
g_option_context_add_main_entries(context, option_entries, "Wayland View");
xkb_option_group = g_option_group_new("xkb",
"Keyboard options",
"Show all XKB options",
NULL, NULL);
g_option_group_add_entries(xkb_option_group, xkb_option_entries);
g_option_context_add_group (context, xkb_option_group);
if (!g_option_context_parse(context, argc, argv, &error)) {
fprintf(stderr, "option parsing failed: %s\n", error->message);
exit(EXIT_FAILURE);
}
d = malloc(sizeof *d);
if (d == NULL)
return NULL;
d->display = wl_display_connect(NULL);
if (d->display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return NULL;
}
wl_list_init(&d->input_list);
/* Set up listener so we'll catch all events. */
wl_display_add_global_listener(d->display,
display_handle_global, d);
/* Process connection events. */
wl_display_iterate(d->display, WL_DISPLAY_READABLE);
if (d->device_name && init_drm(d) < 0)
return NULL;
create_pointer_surfaces(d);
display_render_frame(d);
d->loop = g_main_loop_new(NULL, FALSE);
d->source = wl_glib_source_new(d->display);
g_source_attach(d->source, NULL);
wl_list_init(&d->window_list);
init_xkb(d);
return d;
}
static void *udev_input_init(const char *joypad_driver)
{
udev_input_t *udev = (udev_input_t*)calloc(1, sizeof(*udev));
if (!udev)
return NULL;
udev->udev = udev_new();
if (!udev->udev)
{
RARCH_ERR("Failed to create udev handle.\n");
goto error;
}
udev->monitor = udev_monitor_new_from_netlink(udev->udev, "udev");
if (udev->monitor)
{
udev_monitor_filter_add_match_subsystem_devtype(udev->monitor, "input", NULL);
udev_monitor_enable_receiving(udev->monitor);
}
#ifdef HAVE_XKBCOMMON
if (init_xkb(-1, 0) == -1)
goto error;
#endif
if (!epoll_new(&udev->epfd))
{
RARCH_ERR("Failed to create epoll FD.\n");
goto error;
}
if (!open_devices(udev, "ID_INPUT_KEYBOARD", udev_handle_keyboard))
{
RARCH_ERR("Failed to open keyboard.\n");
goto error;
}
if (!open_devices(udev, "ID_INPUT_MOUSE", udev_handle_mouse))
{
RARCH_ERR("Failed to open mouse.\n");
goto error;
}
if (!open_devices(udev, "ID_INPUT_TOUCHPAD", udev_handle_touchpad))
{
RARCH_ERR("Failed to open touchpads.\n");
goto error;
}
/* If using KMS and we forgot this,
* we could lock ourselves out completely. */
if (!udev->num_devices)
RARCH_WARN("[udev]: Couldn't open any keyboard, mouse or touchpad. Are permissions set correctly for /dev/input/event*?\n");
udev->joypad = input_joypad_init_driver(joypad_driver, udev);
input_keymaps_init_keyboard_lut(rarch_key_map_linux);
linux_terminal_disable_input();
return udev;
error:
udev_input_free(udev);
return NULL;
}