1 files changed, 137 insertions, 114 deletions

diff --git a/sway/input/keyboard.c b/sway/input/keyboard.c
index ce259eb2..f74d0658 100644
--- a/sway/input/keyboard.c
+++ b/sway/input/keyboard.c
@@ -1,15 +1,13 @@
 #include <assert.h>
 #include <limits.h>
 #include <strings.h>
+#include <wlr/config.h>
 #include <wlr/backend/multi.h>
-#include <wlr/backend/session.h>
 #include <wlr/interfaces/wlr_keyboard.h>
-#include <wlr/types/wlr_idle.h>
 #include <wlr/types/wlr_keyboard.h>
 #include <wlr/types/wlr_keyboard_group.h>
 #include <xkbcommon/xkbcommon-names.h>
 #include "sway/commands.h"
-#include "sway/desktop/transaction.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/keyboard.h"
 #include "sway/input/seat.h"
@@ -17,6 +15,10 @@
 #include "sway/ipc-server.h"
 #include "log.h"
 
+#if WLR_HAS_SESSION
+#include <wlr/backend/session.h>
+#endif
+
 static struct modifier_key {
         char *name;
         uint32_t mod;
@@ -30,6 +32,7 @@ static struct modifier_key {
         { XKB_MOD_NAME_NUM, WLR_MODIFIER_MOD2 },
         { "Mod3", WLR_MODIFIER_MOD3 },
         { XKB_MOD_NAME_LOGO, WLR_MODIFIER_LOGO },
+        { "Super", WLR_MODIFIER_LOGO },
         { "Mod5", WLR_MODIFIER_MOD5 },
 };
 
@@ -265,14 +268,12 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard,
                 xkb_keysym_t keysym = pressed_keysyms[i];
                 if (keysym >= XKB_KEY_XF86Switch_VT_1 &&
                                 keysym <= XKB_KEY_XF86Switch_VT_12) {
-                        if (wlr_backend_is_multi(server.backend)) {
-                                struct wlr_session *session =
-                                        wlr_backend_get_session(server.backend);
-                                if (session) {
-                                        unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
-                                        wlr_session_change_vt(session, vt);
-                                }
+#if WLR_HAS_SESSION
+                        if (server.session) {
+                                unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
+                                wlr_session_change_vt(server.session, vt);
                         }
+#endif
                         return true;
                 }
         }
@@ -292,14 +293,12 @@ static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard,
 static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard,
                 xkb_keycode_t keycode, const xkb_keysym_t **keysyms,
                 uint32_t *modifiers) {
-        struct wlr_input_device *device =
-                keyboard->seat_device->input_device->wlr_device;
-        *modifiers = wlr_keyboard_get_modifiers(device->keyboard);
+        *modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
         xkb_mod_mask_t consumed = xkb_state_key_get_consumed_mods2(
-                device->keyboard->xkb_state, keycode, XKB_CONSUMED_MODE_XKB);
+                keyboard->wlr->xkb_state, keycode, XKB_CONSUMED_MODE_XKB);
         *modifiers = *modifiers & ~consumed;
 
-        return xkb_state_key_get_syms(device->keyboard->xkb_state,
+        return xkb_state_key_get_syms(keyboard->wlr->xkb_state,
                 keycode, keysyms);
 }
 
@@ -315,13 +314,11 @@ static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard,
 static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard,
                 xkb_keycode_t keycode, const xkb_keysym_t **keysyms,
                 uint32_t *modifiers) {
-        struct wlr_input_device *device =
-                keyboard->seat_device->input_device->wlr_device;
-        *modifiers = wlr_keyboard_get_modifiers(device->keyboard);
+        *modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
 
         xkb_layout_index_t layout_index = xkb_state_key_get_layout(
-                device->keyboard->xkb_state, keycode);
-        return xkb_keymap_key_get_syms_by_level(device->keyboard->keymap,
+                keyboard->wlr->xkb_state, keycode);
+        return xkb_keymap_key_get_syms_by_level(keyboard->wlr->keymap,
                 keycode, layout_index, 0, keysyms);
 }
 
@@ -361,8 +358,7 @@ static void update_keyboard_state(struct sway_keyboard *keyboard,
                         keyinfo->keycode, &keyinfo->translated_keysyms,
                         &keyinfo->translated_modifiers);
 
-        keyinfo->code_modifiers = wlr_keyboard_get_modifiers(
-                        keyboard->seat_device->input_device->wlr_device->keyboard);
+        keyinfo->code_modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
 
         // Update shortcut model keyinfo
         update_shortcut_state(&keyboard->state_keycodes, raw_keycode, keystate,
@@ -379,16 +375,38 @@ static void update_keyboard_state(struct sway_keyboard *keyboard,
         }
 }
 
+/**
+ * Get keyboard grab of the seat from sway_keyboard if we should forward events
+ * to it.
+ *
+ * Returns NULL if the keyboard is not grabbed by an input method,
+ * or if event is from virtual keyboard of the same client as grab.
+ * TODO: see swaywm/wlroots#2322
+ */
+static struct wlr_input_method_keyboard_grab_v2 *keyboard_get_im_grab(
+                struct sway_keyboard *keyboard) {
+        struct wlr_input_method_v2 *input_method = keyboard->seat_device->
+                sway_seat->im_relay.input_method;
+        struct wlr_virtual_keyboard_v1 *virtual_keyboard =
+                wlr_input_device_get_virtual_keyboard(keyboard->seat_device->input_device->wlr_device);
+        if (!input_method || !input_method->keyboard_grab || (virtual_keyboard &&
+                                wl_resource_get_client(virtual_keyboard->resource) ==
+                                wl_resource_get_client(input_method->keyboard_grab->resource))) {
+                return NULL;
+        }
+        return input_method->keyboard_grab;
+}
+
 static void handle_key_event(struct sway_keyboard *keyboard,
-                struct wlr_event_keyboard_key *event) {
+                struct wlr_keyboard_key_event *event) {
         struct sway_seat *seat = keyboard->seat_device->sway_seat;
         struct wlr_seat *wlr_seat = seat->wlr_seat;
         struct wlr_input_device *wlr_device =
                 keyboard->seat_device->input_device->wlr_device;
         char *device_identifier = input_device_get_identifier(wlr_device);
-        bool exact_identifier = wlr_device->keyboard->group != NULL;
+        bool exact_identifier = keyboard->wlr->group != NULL;
         seat_idle_notify_activity(seat, IDLE_SOURCE_KEYBOARD);
-        bool input_inhibited = seat->exclusive_client != NULL;
+        bool locked = server.session_lock.lock;
         struct sway_keyboard_shortcuts_inhibitor *sway_inhibitor =
                 keyboard_shortcuts_inhibitor_get_for_focused_surface(seat);
         bool shortcuts_inhibited = sway_inhibitor && sway_inhibitor->inhibitor->active;
@@ -406,17 +424,17 @@ static void handle_key_event(struct sway_keyboard *keyboard,
         struct sway_binding *binding_released = NULL;
         get_active_binding(&keyboard->state_keycodes,
                         config->current_mode->keycode_bindings, &binding_released,
-                        keyinfo.code_modifiers, true, input_inhibited,
+                        keyinfo.code_modifiers, true, locked,
                         shortcuts_inhibited, device_identifier,
                         exact_identifier, keyboard->effective_layout);
         get_active_binding(&keyboard->state_keysyms_raw,
                         config->current_mode->keysym_bindings, &binding_released,
-                        keyinfo.raw_modifiers, true, input_inhibited,
+                        keyinfo.raw_modifiers, true, locked,
                         shortcuts_inhibited, device_identifier,
                         exact_identifier, keyboard->effective_layout);
         get_active_binding(&keyboard->state_keysyms_translated,
                         config->current_mode->keysym_bindings, &binding_released,
-                        keyinfo.translated_modifiers, true, input_inhibited,
+                        keyinfo.translated_modifiers, true, locked,
                         shortcuts_inhibited, device_identifier,
                         exact_identifier, keyboard->effective_layout);
 
@@ -438,17 +456,17 @@ static void handle_key_event(struct sway_keyboard *keyboard,
         if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
                 get_active_binding(&keyboard->state_keycodes,
                                 config->current_mode->keycode_bindings, &binding,
-                                keyinfo.code_modifiers, false, input_inhibited,
+                                keyinfo.code_modifiers, false, locked,
                                 shortcuts_inhibited, device_identifier,
                                 exact_identifier, keyboard->effective_layout);
                 get_active_binding(&keyboard->state_keysyms_raw,
                                 config->current_mode->keysym_bindings, &binding,
-                                keyinfo.raw_modifiers, false, input_inhibited,
+                                keyinfo.raw_modifiers, false, locked,
                                 shortcuts_inhibited, device_identifier,
                                 exact_identifier, keyboard->effective_layout);
                 get_active_binding(&keyboard->state_keysyms_translated,
                                 config->current_mode->keysym_bindings, &binding,
-                                keyinfo.translated_modifiers, false, input_inhibited,
+                                keyinfo.translated_modifiers, false, locked,
                                 shortcuts_inhibited, device_identifier,
                                 exact_identifier, keyboard->effective_layout);
         }
@@ -456,10 +474,10 @@ static void handle_key_event(struct sway_keyboard *keyboard,
         // Set up (or clear) keyboard repeat for a pressed binding. Since the
         // binding may remove the keyboard, the timer needs to be updated first
         if (binding && !(binding->flags & BINDING_NOREPEAT) &&
-                        wlr_device->keyboard->repeat_info.delay > 0) {
+                        keyboard->wlr->repeat_info.delay > 0) {
                 keyboard->repeat_binding = binding;
                 if (wl_event_source_timer_update(keyboard->key_repeat_source,
-                                wlr_device->keyboard->repeat_info.delay) < 0) {
+                                keyboard->wlr->repeat_info.delay) < 0) {
                         sway_log(SWAY_DEBUG, "failed to set key repeat timer");
                 }
         } else if (keyboard->repeat_binding) {
@@ -471,7 +489,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                 handled = true;
         }
 
-        if (!handled && wlr_device->keyboard->group) {
+        if (!handled && keyboard->wlr->group) {
                 // Only handle device specific bindings for keyboards in a group
                 free(device_identifier);
                 return;
@@ -489,18 +507,41 @@ static void handle_key_event(struct sway_keyboard *keyboard,
                                 keyinfo.raw_keysyms_len);
         }
 
-        if (!handled || event->state == WL_KEYBOARD_KEY_STATE_RELEASED) {
+        if (event->state == WL_KEYBOARD_KEY_STATE_RELEASED) {
+                // If the pressed event was sent to a client, also send the released
+                // event. In particular, don't send the released event to the IM grab.
                 bool pressed_sent = update_shortcut_state(
-                                &keyboard->state_pressed_sent, event->keycode, event->state,
-                                keyinfo.keycode, 0);
-                if (pressed_sent || event->state == WL_KEYBOARD_KEY_STATE_PRESSED) {
-                        wlr_seat_set_keyboard(wlr_seat, wlr_device);
+                        &keyboard->state_pressed_sent, event->keycode,
+                        event->state, keyinfo.keycode, 0);
+                if (pressed_sent) {
+                        wlr_seat_set_keyboard(wlr_seat, keyboard->wlr);
                         wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
-                                        event->keycode, event->state);
+                                event->keycode, event->state);
+                        handled = true;
+                }
+        }
+
+        if (!handled) {
+                struct wlr_input_method_keyboard_grab_v2 *kb_grab = keyboard_get_im_grab(keyboard);
+
+                if (kb_grab) {
+                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab, keyboard->wlr);
+                        wlr_input_method_keyboard_grab_v2_send_key(kb_grab,
+                                event->time_msec, event->keycode, event->state);
+                        handled = true;
                 }
         }
 
-        transaction_commit_dirty();
+        if (!handled && event->state != WL_KEYBOARD_KEY_STATE_RELEASED) {
+                // If a released event failed pressed sent test, and not in sent to
+                // keyboard grab, it is still not handled. Don't handle released here.
+                update_shortcut_state(
+                        &keyboard->state_pressed_sent, event->keycode, event->state,
+                        keyinfo.keycode, 0);
+                wlr_seat_set_keyboard(wlr_seat, keyboard->wlr);
+                wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
+                                event->keycode, event->state);
+        }
 
         free(device_identifier);
 }
@@ -573,21 +614,18 @@ static void handle_keyboard_group_leave(struct wl_listener *listener,
 }
 
 static int handle_keyboard_repeat(void *data) {
-        struct sway_keyboard *keyboard = (struct sway_keyboard *)data;
-        struct wlr_keyboard *wlr_device =
-                        keyboard->seat_device->input_device->wlr_device->keyboard;
+        struct sway_keyboard *keyboard = data;
         if (keyboard->repeat_binding) {
-                if (wlr_device->repeat_info.rate > 0) {
+                if (keyboard->wlr->repeat_info.rate > 0) {
                         // We queue the next event first, as the command might cancel it
                         if (wl_event_source_timer_update(keyboard->key_repeat_source,
-                                        1000 / wlr_device->repeat_info.rate) < 0) {
+                                        1000 / keyboard->wlr->repeat_info.rate) < 0) {
                                 sway_log(SWAY_DEBUG, "failed to update key repeat timer");
                         }
                 }
 
                 seat_execute_command(keyboard->seat_device->sway_seat,
                                 keyboard->repeat_binding);
-                transaction_commit_dirty();
         }
         return 0;
 }
@@ -614,22 +652,28 @@ static void determine_bar_visibility(uint32_t modifiers) {
 }
 
 static void handle_modifier_event(struct sway_keyboard *keyboard) {
-        struct wlr_input_device *wlr_device =
-                keyboard->seat_device->input_device->wlr_device;
-        if (!wlr_device->keyboard->group) {
-                struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
-                wlr_seat_set_keyboard(wlr_seat, wlr_device);
-                wlr_seat_keyboard_notify_modifiers(wlr_seat,
-                                &wlr_device->keyboard->modifiers);
+        if (!keyboard->wlr->group) {
+                struct wlr_input_method_keyboard_grab_v2 *kb_grab = keyboard_get_im_grab(keyboard);
 
-                uint32_t modifiers = wlr_keyboard_get_modifiers(wlr_device->keyboard);
+                if (kb_grab) {
+                        wlr_input_method_keyboard_grab_v2_set_keyboard(kb_grab, keyboard->wlr);
+                        wlr_input_method_keyboard_grab_v2_send_modifiers(kb_grab,
+                                        &keyboard->wlr->modifiers);
+                } else {
+                        struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
+                        wlr_seat_set_keyboard(wlr_seat, keyboard->wlr);
+                        wlr_seat_keyboard_notify_modifiers(wlr_seat,
+                                        &keyboard->wlr->modifiers);
+                }
+
+                uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->wlr);
                 determine_bar_visibility(modifiers);
         }
 
-        if (wlr_device->keyboard->modifiers.group != keyboard->effective_layout) {
-                keyboard->effective_layout = wlr_device->keyboard->modifiers.group;
+        if (keyboard->wlr->modifiers.group != keyboard->effective_layout) {
+                keyboard->effective_layout = keyboard->wlr->modifiers.group;
 
-                if (!wlr_keyboard_group_from_wlr_keyboard(wlr_device->keyboard)) {
+                if (!wlr_keyboard_group_from_wlr_keyboard(keyboard->wlr)) {
                         ipc_event_input("xkb_layout", keyboard->seat_device->input_device);
                 }
         }
@@ -658,6 +702,7 @@ struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
         }
 
         keyboard->seat_device = device;
+        keyboard->wlr = wlr_keyboard_from_input_device(device->input_device->wlr_device);
         device->keyboard = keyboard;
 
         wl_list_init(&keyboard->keyboard_key.link);
@@ -671,23 +716,11 @@ struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
 
 static void handle_xkb_context_log(struct xkb_context *context,
                 enum xkb_log_level level, const char *format, va_list args) {
-        va_list args_copy;
-        va_copy(args_copy, args);
-        size_t length = vsnprintf(NULL, 0, format, args_copy) + 1;
-        va_end(args_copy);
-
-        char *error = malloc(length);
-        if (!error) {
-                sway_log(SWAY_ERROR, "Failed to allocate libxkbcommon log message");
-                return;
-        }
-
-        va_copy(args_copy, args);
-        vsnprintf(error, length, format, args_copy);
-        va_end(args_copy);
+        char *error = vformat_str(format, args);
 
-        if (error[length - 2] == '\n') {
-                error[length - 2] = '\0';
+        size_t len = strlen(error);
+        if (error[len - 1] == '\n') {
+                error[len - 1] = '\0';
         }
 
         sway_log_importance_t importance = SWAY_DEBUG;
@@ -708,7 +741,7 @@ static void handle_xkb_context_log(struct xkb_context *context,
 
 struct xkb_keymap *sway_keyboard_compile_keymap(struct input_config *ic,
                 char **error) {
-        struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+        struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_SECURE_GETENV);
         if (!sway_assert(context, "cannot create XKB context")) {
                 return NULL;
         }
@@ -722,13 +755,8 @@ struct xkb_keymap *sway_keyboard_compile_keymap(struct input_config *ic,
                 if (!keymap_file) {
                         sway_log_errno(SWAY_ERROR, "cannot read xkb file %s", ic->xkb_file);
                         if (error) {
-                                size_t len = snprintf(NULL, 0, "cannot read xkb file %s: %s",
-                                                ic->xkb_file, strerror(errno)) + 1;
-                                *error = malloc(len);
-                                if (*error) {
-                                        snprintf(*error, len, "cannot read xkb_file %s: %s",
-                                                        ic->xkb_file, strerror(errno));
-                                }
+                                *error = format_str("cannot read xkb file %s: %s",
+                                        ic->xkb_file, strerror(errno));
                         }
                         goto cleanup;
                 }
@@ -766,13 +794,12 @@ static void destroy_empty_wlr_keyboard_group(void *data) {
 
 static void sway_keyboard_group_remove(struct sway_keyboard *keyboard) {
         struct sway_input_device *device = keyboard->seat_device->input_device;
-        struct wlr_keyboard *wlr_keyboard = device->wlr_device->keyboard;
-        struct wlr_keyboard_group *wlr_group = wlr_keyboard->group;
+        struct wlr_keyboard_group *wlr_group = keyboard->wlr->group;
 
         sway_log(SWAY_DEBUG, "Removing keyboard %s from group %p",
                         device->identifier, wlr_group);
 
-        wlr_keyboard_group_remove_keyboard(wlr_keyboard->group, wlr_keyboard);
+        wlr_keyboard_group_remove_keyboard(keyboard->wlr->group, keyboard->wlr);
 
         if (wl_list_empty(&wlr_group->devices)) {
                 sway_log(SWAY_DEBUG, "Destroying empty keyboard group %p",
@@ -797,9 +824,7 @@ static void sway_keyboard_group_remove(struct sway_keyboard *keyboard) {
 }
 
 static void sway_keyboard_group_remove_invalid(struct sway_keyboard *keyboard) {
-        struct sway_input_device *device = keyboard->seat_device->input_device;
-        struct wlr_keyboard *wlr_keyboard = device->wlr_device->keyboard;
-        if (!wlr_keyboard->group) {
+        if (!keyboard->wlr->group) {
                 return;
         }
 
@@ -815,7 +840,7 @@ static void sway_keyboard_group_remove_invalid(struct sway_keyboard *keyboard) {
                 break;
         case KEYBOARD_GROUP_DEFAULT: /* fallthrough */
         case KEYBOARD_GROUP_SMART:;
-                struct wlr_keyboard_group *group = wlr_keyboard->group;
+                struct wlr_keyboard_group *group = keyboard->wlr->group;
                 if (!wlr_keyboard_keymaps_match(keyboard->keymap, group->keyboard.keymap) ||
                                 !repeat_info_match(keyboard, &group->keyboard)) {
                         sway_keyboard_group_remove(keyboard);
@@ -826,7 +851,6 @@ static void sway_keyboard_group_remove_invalid(struct sway_keyboard *keyboard) {
 
 static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
         struct sway_input_device *device = keyboard->seat_device->input_device;
-        struct wlr_keyboard *wlr_keyboard = device->wlr_device->keyboard;
         struct sway_seat *seat = keyboard->seat_device->sway_seat;
         struct seat_config *sc = seat_get_config(seat);
 
@@ -858,7 +882,7 @@ static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
                                         repeat_info_match(keyboard, &wlr_group->keyboard)) {
                                 sway_log(SWAY_DEBUG, "Adding keyboard %s to group %p",
                                                 device->identifier, wlr_group);
-                                wlr_keyboard_group_add_keyboard(wlr_group, wlr_keyboard);
+                                wlr_keyboard_group_add_keyboard(wlr_group, keyboard->wlr);
                                 return;
                         }
                         break;
@@ -897,7 +921,7 @@ static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
                 goto cleanup;
         }
         sway_group->seat_device->input_device->wlr_device =
-                sway_group->wlr_group->input_device;
+                &sway_group->wlr_group->keyboard.base;
 
         if (!sway_keyboard_create(seat, sway_group->seat_device)) {
                 sway_log(SWAY_ERROR, "Failed to allocate sway_keyboard for group");
@@ -906,7 +930,7 @@ static void sway_keyboard_group_add(struct sway_keyboard *keyboard) {
 
         sway_log(SWAY_DEBUG, "Adding keyboard %s to group %p",
                         device->identifier, sway_group->wlr_group);
-        wlr_keyboard_group_add_keyboard(sway_group->wlr_group, wlr_keyboard);
+        wlr_keyboard_group_add_keyboard(sway_group->wlr_group, keyboard->wlr);
 
         wl_list_insert(&seat->keyboard_groups, &sway_group->link);
 
@@ -938,10 +962,8 @@ cleanup:
 void sway_keyboard_configure(struct sway_keyboard *keyboard) {
         struct input_config *input_config =
                 input_device_get_config(keyboard->seat_device->input_device);
-        struct wlr_input_device *wlr_device =
-                keyboard->seat_device->input_device->wlr_device;
 
-        if (!sway_assert(!wlr_keyboard_group_from_wlr_keyboard(wlr_device->keyboard),
+        if (!sway_assert(!wlr_keyboard_group_from_wlr_keyboard(keyboard->wlr),
                                 "sway_keyboard_configure should not be called with a "
                                 "keyboard group's keyboard")) {
                 return;
@@ -983,11 +1005,11 @@ void sway_keyboard_configure(struct sway_keyboard *keyboard) {
 
                 sway_keyboard_group_remove_invalid(keyboard);
 
-                wlr_keyboard_set_keymap(wlr_device->keyboard, keyboard->keymap);
-                wlr_keyboard_set_repeat_info(wlr_device->keyboard,
+                wlr_keyboard_set_keymap(keyboard->wlr, keyboard->keymap);
+                wlr_keyboard_set_repeat_info(keyboard->wlr,
                                 keyboard->repeat_rate, keyboard->repeat_delay);
 
-                if (!wlr_device->keyboard->group) {
+                if (!keyboard->wlr->group) {
                         sway_keyboard_group_add(keyboard);
                 }
 
@@ -1007,40 +1029,42 @@ void sway_keyboard_configure(struct sway_keyboard *keyboard) {
                         }
                 }
                 if (locked_mods) {
-                        wlr_keyboard_notify_modifiers(wlr_device->keyboard, 0, 0,
+                        wlr_keyboard_notify_modifiers(keyboard->wlr, 0, 0,
                                         locked_mods, 0);
                         uint32_t leds = 0;
                         for (uint32_t i = 0; i < WLR_LED_COUNT; ++i) {
-                                if (xkb_state_led_index_is_active(
-                                                wlr_device->keyboard->xkb_state,
-                                                wlr_device->keyboard->led_indexes[i])) {
+                                if (xkb_state_led_index_is_active(keyboard->wlr->xkb_state,
+                                                keyboard->wlr->led_indexes[i])) {
                                         leds |= (1 << i);
                                 }
                         }
-                        if (wlr_device->keyboard->group) {
-                                wlr_keyboard_led_update(
-                                                &wlr_device->keyboard->group->keyboard, leds);
+                        if (keyboard->wlr->group) {
+                                wlr_keyboard_led_update(&keyboard->wlr->group->keyboard, leds);
                         } else {
-                                wlr_keyboard_led_update(wlr_device->keyboard, leds);
+                                wlr_keyboard_led_update(keyboard->wlr, leds);
                         }
                 }
         } else {
                 xkb_keymap_unref(keymap);
                 sway_keyboard_group_remove_invalid(keyboard);
-                if (!wlr_device->keyboard->group) {
+                if (!keyboard->wlr->group) {
                         sway_keyboard_group_add(keyboard);
                 }
         }
 
+        // If the seat has no active keyboard, set this one
         struct wlr_seat *seat = keyboard->seat_device->sway_seat->wlr_seat;
-        wlr_seat_set_keyboard(seat, wlr_device);
+        struct wlr_keyboard *current_keyboard = seat->keyboard_state.keyboard;
+        if (current_keyboard == NULL) {
+                wlr_seat_set_keyboard(seat, keyboard->wlr);
+        }
 
         wl_list_remove(&keyboard->keyboard_key.link);
-        wl_signal_add(&wlr_device->keyboard->events.key, &keyboard->keyboard_key);
+        wl_signal_add(&keyboard->wlr->events.key, &keyboard->keyboard_key);
         keyboard->keyboard_key.notify = handle_keyboard_key;
 
         wl_list_remove(&keyboard->keyboard_modifiers.link);
-        wl_signal_add(&wlr_device->keyboard->events.modifiers,
+        wl_signal_add(&keyboard->wlr->events.modifiers,
                 &keyboard->keyboard_modifiers);
         keyboard->keyboard_modifiers.notify = handle_keyboard_modifiers;
 
@@ -1057,12 +1081,11 @@ void sway_keyboard_destroy(struct sway_keyboard *keyboard) {
         if (!keyboard) {
                 return;
         }
-        if (keyboard->seat_device->input_device->wlr_device->keyboard->group) {
+        if (keyboard->wlr->group) {
                 sway_keyboard_group_remove(keyboard);
         }
         struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
-        struct sway_input_device *device = keyboard->seat_device->input_device;
-        if (wlr_seat_get_keyboard(wlr_seat) == device->wlr_device->keyboard) {
+        if (wlr_seat_get_keyboard(wlr_seat) == keyboard->wlr) {
                 wlr_seat_set_keyboard(wlr_seat, NULL);
         }
         if (keyboard->keymap) {