} key_t;

/* Physical or virtual keyboard group. */

typedef struct {

    struct wlr_keyboard_group      *wlr_group;

    int                             nsyms;

    uint32_t                        repeat_keycode; /* Valid only when nsyms is nonzero. */

    const xkb_keysym_t             *keysyms;        /* Valid only when nsyms is nonzero. */

    uint32_t                        mods;           /* Valid only when nsyms is nonzero. */

    struct wl_event_source         *key_repeat_source;

static void              popup_commit(struct wl_listener *listener, void *data);

static void              popup_destroy(struct wl_listener *listener, void *data);

static void              create_decoration(struct wl_listener *listener, void *data);

static void              create_idle_inhibitor(struct wl_listener *listener, void *data);

static void              create_keyboard(struct wlr_keyboard *keyboard);

static void              create_layer_surface(struct wl_listener *listener, void *data);

static void              create_lock_surface(struct wl_listener *listener, void *data);

static void              create_monitor(struct wl_listener *listener, void *data);

static void              create_notify(struct wl_listener *listener, void *data);

static void              create_pointer(struct wlr_pointer *pointer);

    /* Add the keyboard to the shared group. */

    wlr_keyboard_group_add_keyboard(kb_group->wlr_group, keyboard);

}

/* Create a keyboard group with the configured key map and repeat settings. */

    keyboard_group_t   *group = pool_take(&keyboard_group_pool);

    struct xkb_context *context;

    struct xkb_keymap  *keymap;

    if (!group)

    if (!group->wlr_group) {

        pool_release(&keyboard_group_pool, group);

        return nullptr;

    }

    /* Prepare an XKB keymap and assign it to the keyboard group. */

    context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);

    if (!(keymap = xkb_keymap_new_from_names(context, &xkb_rules, XKB_KEYMAP_COMPILE_NO_FLAGS)))

    group->key_repeat_source = wl_event_loop_add_timer(event_loop, key_repeat, group);

    /* Wayland exposes one active keyboard per seat, so combine physical

     * keyboards into one group. */

        wlr_seat_set_keyboard(seat, &group->wlr_group->keyboard);

    return group;

}

/* Choose the layer that contains popups belonging to a layer-shell surface. */

void destroy_keyboard_group(struct wl_listener *listener, void *data) {

    keyboard_group_t *group       = wl_container_of(listener, group, destroy);

    int               was_current = wlr_seat_get_keyboard(seat) == &group->wlr_group->keyboard;

    bool              is_main     = group == kb_group;

        virtual_keyboards--;

    wl_event_source_remove(group->key_repeat_source);

    wl_list_remove(&group->key.link);

    wl_list_remove(&group->modifiers.link);

    wl_list_remove(&group->destroy.link);

    im_mgr = wlr_input_method_manager_v2_create(dpy);

    listen_global(&im_mgr->events.new_input_method, &new_input_method);

    ti_mgr = wlr_text_input_manager_v3_create(dpy);

    listen_global(&ti_mgr->events.new_text_input, &new_text_input);

    if (!kb_group)

        die("failed to allocate primary keyboard group");

    wl_list_init(&kb_group->destroy.link);

/* Create an independent keyboard group for a virtual keyboard. */

void virtual_keyboard(struct wl_listener *listener, void *data) {

    struct wlr_virtual_keyboard_v1 *kb = data;

    /* Give each virtual keyboard its own group. */

    if (!group) {

        wl_resource_post_no_memory(kb->resource);

        return;

    }

    /* Use the virtual keyboard's key mapping. */

    wlr_keyboard_set_keymap(&kb->keyboard, group->wlr_group->keyboard.keymap);

    LISTEN(&kb->keyboard.base.events.destroy, &group->destroy, destroy_keyboard_group);

    /* Add the virtual keyboard to its group. */

    wlr_keyboard_group_add_keyboard(group->wlr_group, &kb->keyboard);