Move keyboard logic to wlr_{keyboard,seat}

This commit is contained in:
Drew DeVault 2017-09-24 14:12:56 -04:00
parent b84d59403f
commit 61e451ea1b
15 changed files with 257 additions and 87 deletions

View File

@ -68,5 +68,5 @@ void handle_keyboard_key(struct libinput_event *event,
wlr_event.state = WLR_KEY_PRESSED; wlr_event.state = WLR_KEY_PRESSED;
break; break;
} }
wl_signal_emit(&wlr_dev->keyboard->events.key, &wlr_event); wlr_keyboard_update_state(wlr_dev->keyboard, &wlr_event);
} }

View File

@ -128,17 +128,15 @@ static const struct wl_pointer_listener pointer_listener = {
static void keyboard_handle_keymap(void *data, struct wl_keyboard *wl_keyboard, static void keyboard_handle_keymap(void *data, struct wl_keyboard *wl_keyboard,
uint32_t format, int32_t fd, uint32_t size) { uint32_t format, int32_t fd, uint32_t size) {
// TODO: set keymap
} }
static void keyboard_handle_enter(void *data, struct wl_keyboard *wl_keyboard, static void keyboard_handle_enter(void *data, struct wl_keyboard *wl_keyboard,
uint32_t serial, struct wl_surface *surface, struct wl_array *keys) { uint32_t serial, struct wl_surface *surface, struct wl_array *keys) {
} }
static void keyboard_handle_leave(void *data, struct wl_keyboard *wl_keyboard, static void keyboard_handle_leave(void *data, struct wl_keyboard *wl_keyboard,
uint32_t serial, struct wl_surface *surface) { uint32_t serial, struct wl_surface *surface) {
} }
static void keyboard_handle_key(void *data, struct wl_keyboard *wl_keyboard, static void keyboard_handle_key(void *data, struct wl_keyboard *wl_keyboard,
@ -151,7 +149,7 @@ static void keyboard_handle_key(void *data, struct wl_keyboard *wl_keyboard,
wlr_event.state = state; wlr_event.state = state;
wlr_event.time_sec = time / 1000; wlr_event.time_sec = time / 1000;
wlr_event.time_usec = time * 1000; wlr_event.time_usec = time * 1000;
wl_signal_emit(&dev->keyboard->events.key, &wlr_event); wlr_keyboard_update_state(dev->keyboard, &wlr_event);
} }
static void keyboard_handle_modifiers(void *data, struct wl_keyboard *wl_keyboard, static void keyboard_handle_modifiers(void *data, struct wl_keyboard *wl_keyboard,

View File

@ -32,9 +32,6 @@
#include "shared.h" #include "shared.h"
#include <assert.h> #include <assert.h>
// TODO: move to common header?
int os_create_anonymous_file(off_t size);
struct sample_state; struct sample_state;
struct example_xdg_surface_v6 { struct example_xdg_surface_v6 {
@ -75,13 +72,9 @@ struct sample_state {
struct wlr_xdg_shell_v6 *xdg_shell; struct wlr_xdg_shell_v6 *xdg_shell;
struct wlr_data_device_manager *data_device_manager; struct wlr_data_device_manager *data_device_manager;
struct wl_resource *focus; struct wl_resource *focus;
struct wl_listener keyboard_bound;
struct wlr_xwayland *xwayland; struct wlr_xwayland *xwayland;
struct wlr_gamma_control_manager *gamma_control_manager; struct wlr_gamma_control_manager *gamma_control_manager;
bool mod_down; bool mod_down;
int keymap_fd;
size_t keymap_size;
uint32_t serial;
struct motion_context motion_context; struct motion_context motion_context;
@ -335,61 +328,11 @@ static void handle_keyboard_key(struct keyboard_state *keyboard,
uint32_t keycode, xkb_keysym_t sym, enum wlr_key_state key_state) { uint32_t keycode, xkb_keysym_t sym, enum wlr_key_state key_state) {
struct compositor_state *state = keyboard->compositor; struct compositor_state *state = keyboard->compositor;
struct sample_state *sample = state->data; struct sample_state *sample = state->data;
struct wl_resource *res = NULL;
struct wlr_seat_handle *seat_handle = NULL;
wl_list_for_each(res, &sample->wlr_compositor->surfaces, link) {
break;
}
if (res) {
seat_handle = wlr_seat_handle_for_client(sample->wl_seat,
wl_resource_get_client(res));
}
if (res != sample->focus && seat_handle && seat_handle->keyboard) {
struct wl_array keys;
wl_array_init(&keys);
uint32_t serial = wl_display_next_serial(state->display);
wl_keyboard_send_enter(seat_handle->keyboard, serial, res, &keys);
sample->focus = res;
}
if (seat_handle && seat_handle->keyboard) {
uint32_t depressed = xkb_state_serialize_mods(keyboard->xkb_state,
XKB_STATE_MODS_DEPRESSED);
uint32_t latched = xkb_state_serialize_mods(keyboard->xkb_state,
XKB_STATE_MODS_LATCHED);
uint32_t locked = xkb_state_serialize_mods(keyboard->xkb_state,
XKB_STATE_MODS_LOCKED);
uint32_t group = xkb_state_serialize_layout(keyboard->xkb_state,
XKB_STATE_LAYOUT_EFFECTIVE);
uint32_t modifiers_serial = wl_display_next_serial(state->display);
uint32_t key_serial = wl_display_next_serial(state->display);
wl_keyboard_send_modifiers(seat_handle->keyboard, modifiers_serial,
depressed, latched, locked, group);
wl_keyboard_send_key(seat_handle->keyboard, key_serial, 0, keycode,
key_state);
}
if (sym == XKB_KEY_Super_L || sym == XKB_KEY_Super_R) { if (sym == XKB_KEY_Super_L || sym == XKB_KEY_Super_R) {
sample->mod_down = key_state == WLR_KEY_PRESSED; sample->mod_down = key_state == WLR_KEY_PRESSED;
} }
} }
static void handle_keyboard_bound(struct wl_listener *listener, void *data) {
struct wlr_seat_handle *handle = data;
struct sample_state *state =
wl_container_of(listener, state, keyboard_bound);
wl_keyboard_send_keymap(handle->keyboard, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
state->keymap_fd, state->keymap_size);
if (wl_resource_get_version(handle->keyboard) >= 2) {
wl_keyboard_send_repeat_info(handle->keyboard, 25, 600);
}
}
static struct wlr_xdg_surface_v6 *example_xdg_surface_at( static struct wlr_xdg_surface_v6 *example_xdg_surface_at(
struct sample_state *sample, int lx, int ly) { struct sample_state *sample, int lx, int ly) {
struct wlr_xdg_surface_v6 *xdg_surface; struct wlr_xdg_surface_v6 *xdg_surface;
@ -550,6 +493,25 @@ static void handle_input_add(struct compositor_state *state,
example_config_configure_cursor(sample->config, sample->cursor, example_config_configure_cursor(sample->config, sample->cursor,
sample->compositor); sample->compositor);
} }
if (device->type == WLR_INPUT_DEVICE_KEYBOARD) {
struct xkb_rule_names rules;
memset(&rules, 0, sizeof(rules));
rules.rules = getenv("XKB_DEFAULT_RULES");
rules.model = getenv("XKB_DEFAULT_MODEL");
rules.layout = getenv("XKB_DEFAULT_LAYOUT");
rules.variant = getenv("XKB_DEFAULT_VARIANT");
rules.options = getenv("XKB_DEFAULT_OPTIONS");
struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!context) {
wlr_log(L_ERROR, "Failed to create XKB context");
exit(1);
}
wlr_keyboard_set_keymap(device->keyboard, xkb_map_new_from_names(
context, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
xkb_context_unref(context);
wlr_seat_attach_keyboard(sample->wl_seat, device);
}
} }
static void handle_output_add(struct output_state *ostate) { static void handle_output_add(struct output_state *ostate) {
@ -669,35 +631,25 @@ int main(int argc, char *argv[]) {
state.wl_seat = wlr_seat_create(compositor.display, "seat0"); state.wl_seat = wlr_seat_create(compositor.display, "seat0");
assert(state.wl_seat); assert(state.wl_seat);
state.keyboard_bound.notify = handle_keyboard_bound;
wl_signal_add(&state.wl_seat->events.keyboard_bound, &state.keyboard_bound);
wlr_seat_set_capabilities(state.wl_seat, WL_SEAT_CAPABILITY_KEYBOARD wlr_seat_set_capabilities(state.wl_seat, WL_SEAT_CAPABILITY_KEYBOARD
| WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_TOUCH); | WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_TOUCH);
struct keyboard_state *kbstate;
wl_list_for_each(kbstate, &compositor.keyboards, link) {
char *keymap = xkb_keymap_get_as_string(kbstate->keymap,
XKB_KEYMAP_FORMAT_TEXT_V1);
state.keymap_size = strlen(keymap);
state.keymap_fd = os_create_anonymous_file(state.keymap_size);
void *ptr =
mmap(NULL, state.keymap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
state.keymap_fd, 0);
strcpy(ptr, keymap);
free(keymap);
break;
}
state.xwayland = wlr_xwayland_create(compositor.display, state.xwayland = wlr_xwayland_create(compositor.display,
state.wlr_compositor); state.wlr_compositor);
compositor.keyboard_key_cb = handle_keyboard_key; compositor.keyboard_key_cb = handle_keyboard_key;
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
wl_list_remove(&state.new_xdg_surface_v6.link); wl_list_remove(&state.new_xdg_surface_v6.link);
wlr_xwayland_destroy(state.xwayland); wlr_xwayland_destroy(state.xwayland);
close(state.keymap_fd);
wlr_seat_destroy(state.wl_seat); wlr_seat_destroy(state.wl_seat);
wlr_gamma_control_manager_destroy(state.gamma_control_manager); wlr_gamma_control_manager_destroy(state.gamma_control_manager);
wlr_data_device_manager_destroy(state.data_device_manager); wlr_data_device_manager_destroy(state.data_device_manager);

View File

@ -203,6 +203,11 @@ int main(int argc, char *argv[]) {
wlr_texture_upload_pixels(state.cat_texture, WL_SHM_FORMAT_ABGR8888, wlr_texture_upload_pixels(state.cat_texture, WL_SHM_FORMAT_ABGR8888,
cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data); cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data);
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
wlr_texture_destroy(state.cat_texture); wlr_texture_destroy(state.cat_texture);

View File

@ -333,6 +333,11 @@ int main(int argc, char *argv[]) {
wlr_cursor_set_xcursor(state.cursor, state.xcursor); wlr_cursor_set_xcursor(state.cursor, state.xcursor);
compositor_init(&compositor); compositor_init(&compositor);
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
compositor_fini(&compositor); compositor_fini(&compositor);

View File

@ -146,6 +146,11 @@ int main(int argc, char *argv[]) {
wlr_texture_upload_pixels(state.cat_texture, WL_SHM_FORMAT_ABGR8888, wlr_texture_upload_pixels(state.cat_texture, WL_SHM_FORMAT_ABGR8888,
cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data); cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data);
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
wlr_texture_destroy(state.cat_texture); wlr_texture_destroy(state.cat_texture);

View File

@ -537,11 +537,6 @@ void compositor_init(struct compositor_state *state) {
wlr_log(L_INFO, "Running compositor on wayland display '%s'", socket); wlr_log(L_INFO, "Running compositor on wayland display '%s'", socket);
setenv("_WAYLAND_DISPLAY", socket, true); setenv("_WAYLAND_DISPLAY", socket, true);
if (!wlr_backend_start(state->backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(wlr);
exit(1);
}
} }
void compositor_fini(struct compositor_state *state) { void compositor_fini(struct compositor_state *state) {

View File

@ -9,6 +9,7 @@
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/util/log.h>
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include "shared.h" #include "shared.h"
@ -52,6 +53,11 @@ int main() {
.output_frame_cb = handle_output_frame, .output_frame_cb = handle_output_frame,
}; };
compositor_init(&compositor); compositor_init(&compositor);
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
compositor_fini(&compositor); compositor_fini(&compositor);
} }

View File

@ -158,6 +158,11 @@ int main(int argc, char *argv[]) {
wlr_log(L_ERROR, "Could not start compositor, OOM"); wlr_log(L_ERROR, "Could not start compositor, OOM");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
wlr_renderer_destroy(state.renderer); wlr_renderer_destroy(state.renderer);

View File

@ -120,6 +120,11 @@ int main(int argc, char *argv[]) {
wlr_texture_upload_pixels(state.cat_texture, WL_SHM_FORMAT_ARGB8888, wlr_texture_upload_pixels(state.cat_texture, WL_SHM_FORMAT_ARGB8888,
cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data); cat_tex.width, cat_tex.width, cat_tex.height, cat_tex.pixel_data);
if (!wlr_backend_start(compositor.backend)) {
wlr_log(L_ERROR, "Failed to start backend");
wlr_backend_destroy(compositor.backend);
exit(1);
}
wl_display_run(compositor.display); wl_display_run(compositor.display);
wlr_texture_destroy(state.cat_texture); wlr_texture_destroy(state.cat_texture);

View File

@ -10,5 +10,7 @@ struct wlr_keyboard_impl {
void wlr_keyboard_init(struct wlr_keyboard *keyboard, struct wlr_keyboard_impl *impl); void wlr_keyboard_init(struct wlr_keyboard *keyboard, struct wlr_keyboard_impl *impl);
void wlr_keyboard_destroy(struct wlr_keyboard *keyboard); void wlr_keyboard_destroy(struct wlr_keyboard *keyboard);
void wlr_keyboard_update_state(struct wlr_keyboard *keyboard,
struct wlr_event_keyboard_key *event);
#endif #endif

View File

@ -1,7 +1,8 @@
#ifndef _WLR_TYPES_KEYBOARD_H #ifndef _WLR_TYPES_KEYBOARD_H
#define _WLR_TYPES_KEYBOARD_H #define _WLR_TYPES_KEYBOARD_H
#include <wayland-server.h>
#include <stdint.h> #include <stdint.h>
#include <wayland-server.h>
#include <xkbcommon/xkbcommon.h>
enum WLR_KEYBOARD_LED { enum WLR_KEYBOARD_LED {
WLR_LED_NUM_LOCK = 1, WLR_LED_NUM_LOCK = 1,
@ -14,9 +15,17 @@ struct wlr_keyboard_impl;
struct wlr_keyboard { struct wlr_keyboard {
struct wlr_keyboard_impl *impl; struct wlr_keyboard_impl *impl;
// TODO: Should this store key repeat info too?
int keymap_fd;
size_t keymap_size;
struct xkb_keymap *keymap;
struct xkb_state *xkb_state;
xkb_led_index_t leds[WLR_LED_LAST];
struct { struct {
struct wl_signal key; struct wl_signal key;
struct wl_signal keymap;
} events; } events;
void *data; void *data;
@ -36,4 +45,7 @@ struct wlr_event_keyboard_key {
enum wlr_key_state state; enum wlr_key_state state;
}; };
void wlr_keyboard_set_keymap(struct wlr_keyboard *kb,
struct xkb_keymap *keymap);
#endif #endif

View File

@ -2,6 +2,7 @@
#define _WLR_TYPES_SEAT_H #define _WLR_TYPES_SEAT_H
#include <wlr/types/wlr_surface.h> #include <wlr/types/wlr_surface.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/types/wlr_keyboard.h>
#include <wayland-server.h> #include <wayland-server.h>
/** /**
@ -12,6 +13,7 @@
struct wlr_seat_handle { struct wlr_seat_handle {
struct wl_resource *wl_resource; struct wl_resource *wl_resource;
struct wlr_seat *wlr_seat; struct wlr_seat *wlr_seat;
struct wlr_seat_keyboard *seat_keyboard;
struct wl_resource *pointer; struct wl_resource *pointer;
struct wl_resource *keyboard; struct wl_resource *keyboard;
@ -30,10 +32,20 @@ struct wlr_seat_pointer_state {
struct wl_listener focus_resource_destroy_listener; struct wl_listener focus_resource_destroy_listener;
}; };
struct wlr_seat_keyboard {
struct wlr_seat *seat;
struct wlr_keyboard *keyboard;
struct wl_listener key;
struct wl_listener keymap;
struct wl_listener destroy;
struct wl_list link;
};
struct wlr_seat { struct wlr_seat {
struct wl_global *wl_global; struct wl_global *wl_global;
struct wl_display *display; struct wl_display *display;
struct wl_list handles; struct wl_list handles;
struct wl_list keyboards;
char *name; char *name;
uint32_t capabilities; uint32_t capabilities;
struct wlr_data_device *data_device; struct wlr_data_device *data_device;
@ -43,7 +55,6 @@ struct wlr_seat {
struct { struct {
struct wl_signal client_bound; struct wl_signal client_bound;
struct wl_signal client_unbound; struct wl_signal client_unbound;
struct wl_signal keyboard_bound;
} events; } events;
void *data; void *data;
@ -112,4 +123,18 @@ uint32_t wlr_seat_pointer_send_button(struct wlr_seat *wlr_seat, uint32_t time,
void wlr_seat_pointer_send_axis(struct wlr_seat *wlr_seat, uint32_t time, void wlr_seat_pointer_send_axis(struct wlr_seat *wlr_seat, uint32_t time,
enum wlr_axis_orientation orientation, double value); enum wlr_axis_orientation orientation, double value);
/**
* Attaches this keyboard to the seat. Key events from this keyboard will be
* propegated to the focused client.
*/
void wlr_seat_attach_keyboard(struct wlr_seat *seat,
struct wlr_input_device *dev);
/**
* Detaches this keyboard from the seat. This is done automatically when the
* keyboard is destroyed; you only need to use this if you want to remove it for
* some other reason.
*/
void wlr_seat_detach_keyboard(struct wlr_seat *seat, struct wlr_keyboard *kb);
#endif #endif

View File

@ -1,13 +1,39 @@
#include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/types/wlr_keyboard.h> #include <wlr/types/wlr_keyboard.h>
#include <wlr/interfaces/wlr_keyboard.h> #include <wlr/interfaces/wlr_keyboard.h>
#include <wlr/util/log.h>
int os_create_anonymous_file(off_t size);
static void keyboard_led_update(struct wlr_keyboard *keyboard) {
uint32_t leds = 0;
for (uint32_t i = 0; i < WLR_LED_LAST; ++i) {
if (xkb_state_led_index_is_active(keyboard->xkb_state, keyboard->leds[i])) {
leds |= (1 << i);
}
}
wlr_keyboard_led_update(keyboard, leds);
}
void wlr_keyboard_update_state(struct wlr_keyboard *keyboard,
struct wlr_event_keyboard_key *event) {
uint32_t keycode = event->keycode + 8;
xkb_state_update_key(keyboard->xkb_state, keycode,
event->state == WLR_KEY_PRESSED ? XKB_KEY_DOWN : XKB_KEY_UP);
keyboard_led_update(keyboard);
wl_signal_emit(&keyboard->events.key, &event);
}
void wlr_keyboard_init(struct wlr_keyboard *kb, void wlr_keyboard_init(struct wlr_keyboard *kb,
struct wlr_keyboard_impl *impl) { struct wlr_keyboard_impl *impl) {
kb->impl = impl; kb->impl = impl;
wl_signal_init(&kb->events.key); wl_signal_init(&kb->events.key);
wl_signal_init(&kb->events.keymap);
} }
void wlr_keyboard_destroy(struct wlr_keyboard *kb) { void wlr_keyboard_destroy(struct wlr_keyboard *kb) {
@ -17,6 +43,7 @@ void wlr_keyboard_destroy(struct wlr_keyboard *kb) {
wl_list_remove(&kb->events.key.listener_list); wl_list_remove(&kb->events.key.listener_list);
free(kb); free(kb);
} }
close(kb->keymap_fd);
} }
void wlr_keyboard_led_update(struct wlr_keyboard *kb, uint32_t leds) { void wlr_keyboard_led_update(struct wlr_keyboard *kb, uint32_t leds) {
@ -24,3 +51,26 @@ void wlr_keyboard_led_update(struct wlr_keyboard *kb, uint32_t leds) {
kb->impl->led_update(kb, leds); kb->impl->led_update(kb, leds);
} }
} }
void wlr_keyboard_set_keymap(struct wlr_keyboard *kb,
struct xkb_keymap *keymap) {
kb->keymap = keymap;
assert(kb->xkb_state = xkb_state_new(kb->keymap));
const char *led_names[3] = {
XKB_LED_NAME_NUM,
XKB_LED_NAME_CAPS,
XKB_LED_NAME_SCROLL
};
for (uint32_t i = 0; i < 3; ++i) {
kb->leds[i] = xkb_map_led_get_index(kb->keymap, led_names[i]);
}
char *keymap_str = xkb_keymap_get_as_string(kb->keymap,
XKB_KEYMAP_FORMAT_TEXT_V1);
kb->keymap_size = strlen(keymap_str);
kb->keymap_fd = os_create_anonymous_file(kb->keymap_size);
void *ptr = mmap(NULL, kb->keymap_size,
PROT_READ | PROT_WRITE, MAP_SHARED, kb->keymap_fd, 0);
strcpy(ptr, keymap_str);
free(keymap_str);
wl_signal_emit(&kb->events.keymap, kb);
}

View File

@ -78,7 +78,6 @@ static void wl_seat_get_keyboard(struct wl_client *client,
wl_resource_get_version(_handle), id); wl_resource_get_version(_handle), id);
wl_resource_set_implementation(handle->keyboard, &wl_keyboard_impl, wl_resource_set_implementation(handle->keyboard, &wl_keyboard_impl,
handle, &wl_keyboard_destroy); handle, &wl_keyboard_destroy);
wl_signal_emit(&handle->wlr_seat->events.keyboard_bound, handle);
} }
static const struct wl_touch_interface wl_touch_impl = { static const struct wl_touch_interface wl_touch_impl = {
@ -180,10 +179,10 @@ struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name) {
wlr_seat->display = display; wlr_seat->display = display;
wlr_seat->name = strdup(name); wlr_seat->name = strdup(name);
wl_list_init(&wlr_seat->handles); wl_list_init(&wlr_seat->handles);
wl_list_init(&wlr_seat->keyboards);
wl_signal_init(&wlr_seat->events.client_bound); wl_signal_init(&wlr_seat->events.client_bound);
wl_signal_init(&wlr_seat->events.client_unbound); wl_signal_init(&wlr_seat->events.client_unbound);
wl_signal_init(&wlr_seat->events.keyboard_bound);
wl_list_init(&wlr_seat->pointer_state.focus_resource_destroy_listener.link); wl_list_init(&wlr_seat->pointer_state.focus_resource_destroy_listener.link);
wl_list_init(&wlr_seat->pointer_state.focus_surface_destroy_listener.link); wl_list_init(&wlr_seat->pointer_state.focus_surface_destroy_listener.link);
@ -295,6 +294,13 @@ void wlr_seat_pointer_enter(struct wlr_seat *wlr_seat,
wl_pointer_send_frame(focused_handle->pointer); wl_pointer_send_frame(focused_handle->pointer);
} }
// TEMPORARY
if (focused_handle && focused_handle->pointer && focused_surface) {
uint32_t serial = wl_display_next_serial(wlr_seat->display);
wl_keyboard_send_leave(focused_handle->keyboard,
serial, focused_surface->resource);
}
// enter the current surface // enter the current surface
if (handle && handle->pointer) { if (handle && handle->pointer) {
uint32_t serial = wl_display_next_serial(wlr_seat->display); uint32_t serial = wl_display_next_serial(wlr_seat->display);
@ -303,6 +309,15 @@ void wlr_seat_pointer_enter(struct wlr_seat *wlr_seat,
wl_pointer_send_frame(handle->pointer); wl_pointer_send_frame(handle->pointer);
} }
// TEMPORARY
if (handle && handle->keyboard) {
wlr_log(L_DEBUG, "Sending keyboard");
struct wl_array keys;
wl_array_init(&keys);
uint32_t serial = wl_display_next_serial(wlr_seat->display);
wl_keyboard_send_enter(handle->keyboard, serial, surface->resource, &keys);
}
// reinitialize the focus destroy events // reinitialize the focus destroy events
wl_list_remove( wl_list_remove(
&wlr_seat->pointer_state.focus_surface_destroy_listener.link); &wlr_seat->pointer_state.focus_surface_destroy_listener.link);
@ -373,3 +388,93 @@ void wlr_seat_pointer_send_axis(struct wlr_seat *wlr_seat, uint32_t time,
wl_pointer_send_frame(pointer); wl_pointer_send_frame(pointer);
} }
static void keyboard_key_notify(struct wl_listener *listener, void *data) {
struct wlr_seat_keyboard *seat_kb = wl_container_of(
listener, seat_kb, key);
struct wlr_seat *seat = seat_kb->seat;
struct wlr_seat_handle *handle = seat->pointer_state.focused_handle;
if (!handle || !handle->keyboard) {
return;
}
struct wlr_keyboard *keyboard = seat_kb->keyboard;
struct wlr_event_keyboard_key *event = data;
enum wlr_key_state key_state = event->state;
if (handle->seat_keyboard != seat_kb) {
// TODO: We should probably lift all of the keys set by the other
// keyboard
wlr_log(L_DEBUG, "Sending key map");
wl_keyboard_send_keymap(handle->keyboard,
WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
seat_kb->keyboard->keymap_fd,
seat_kb->keyboard->keymap_size);
if (wl_resource_get_version(handle->keyboard) >= 2) {
// TODO: Make this better
wl_keyboard_send_repeat_info(handle->keyboard, 25, 600);
}
handle->seat_keyboard = seat_kb;
}
uint32_t depressed = xkb_state_serialize_mods(keyboard->xkb_state,
XKB_STATE_MODS_DEPRESSED);
uint32_t latched = xkb_state_serialize_mods(keyboard->xkb_state,
XKB_STATE_MODS_LATCHED);
uint32_t locked = xkb_state_serialize_mods(keyboard->xkb_state,
XKB_STATE_MODS_LOCKED);
uint32_t group = xkb_state_serialize_layout(keyboard->xkb_state,
XKB_STATE_LAYOUT_EFFECTIVE);
uint32_t modifiers_serial = wl_display_next_serial(seat->display);
uint32_t key_serial = wl_display_next_serial(seat->display);
wl_keyboard_send_modifiers(handle->keyboard, modifiers_serial,
depressed, latched, locked, group);
wl_keyboard_send_key(handle->keyboard, key_serial,
(uint32_t)event->time_usec, event->keycode, key_state);
}
static void keyboard_keymap_notify(struct wl_listener *listener, void *data) {
struct wlr_seat_keyboard *seat_kb = wl_container_of(
listener, seat_kb, keymap);
wlr_log(L_DEBUG, "Keymap event for %p", seat_kb);
}
static void keyboard_destroy_notify(struct wl_listener *listener, void *data) {
struct wlr_seat_keyboard *seat_kb = wl_container_of(
listener, seat_kb, destroy);
wlr_seat_detach_keyboard(seat_kb->seat, seat_kb->keyboard);
}
void wlr_seat_attach_keyboard(struct wlr_seat *seat,
struct wlr_input_device *dev) {
assert(seat && dev && dev->type == WLR_INPUT_DEVICE_KEYBOARD);
struct wlr_keyboard *kb = dev->keyboard;
struct wlr_seat_keyboard *seat_kb =
calloc(1, sizeof(struct wlr_seat_keyboard));
seat_kb->keyboard = kb;
seat_kb->seat = seat;
wl_list_init(&seat_kb->key.link);
seat_kb->key.notify = keyboard_key_notify;
wl_signal_add(&kb->events.key, &seat_kb->key);
wl_list_init(&seat_kb->keymap.link);
seat_kb->keymap.notify = keyboard_keymap_notify;
wl_signal_add(&kb->events.keymap, &seat_kb->keymap);
wl_list_init(&seat_kb->destroy.link);
seat_kb->destroy.notify = keyboard_destroy_notify;
wl_signal_add(&dev->events.destroy, &seat_kb->destroy);
wl_list_insert(&seat->keyboards, &seat_kb->link);
}
void wlr_seat_detach_keyboard(struct wlr_seat *seat, struct wlr_keyboard *kb) {
struct wlr_seat_keyboard *seat_kb, *_tmp;
wl_list_for_each_safe(seat_kb, _tmp, &seat->keyboards, link) {
if (seat_kb->keyboard == kb) {
wl_list_remove(&seat_kb->link);
wl_list_remove(&seat_kb->key.link);
wl_list_remove(&seat_kb->keymap.link);
wl_list_remove(&seat_kb->destroy.link);
free(seat_kb);
break;
}
}
}