#include <wlr/types/wlr_keyboard_group.h>

	struct wlr_keyboard *wlr_keyboard;

	struct wlr_keyboard_group *wlr_group;

	struct wl_listener destroy;
} Keyboard;

} KeyboardGroup;

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

static struct wl_list keyboards;

static KeyboardGroup kb_group;

	/* Remove event source that use the dpy event loop before destroying dpy */
	wl_event_source_remove(kb_group.key_repeat_source);

cleanupkeyboard(struct wl_listener *listener, void *data)
{
	Keyboard *kb = wl_container_of(listener, kb, destroy);
	wl_event_source_remove(kb->key_repeat_source);
	wl_list_remove(&kb->link);
	wl_list_remove(&kb->modifiers.link);
	wl_list_remove(&kb->key.link);
	wl_list_remove(&kb->destroy.link);
	free(kb);
}
void

	struct xkb_context *context;
	struct xkb_keymap *keymap;
	Keyboard *kb = keyboard->data = ecalloc(1, sizeof(*kb));
	kb->wlr_keyboard = keyboard;
	/* Prepare an XKB keymap and assign it to the keyboard. */
	context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
	keymap = xkb_keymap_new_from_names(context, &xkb_rules,
		XKB_KEYMAP_COMPILE_NO_FLAGS);
	if (!keymap)
		die("createkeyboard: failed to compile keymap");
	wlr_keyboard_set_keymap(keyboard, keymap);
	xkb_keymap_unref(keymap);
	xkb_context_unref(context);

	/* Set the keymap to match the group keymap */
	wlr_keyboard_set_keymap(keyboard, kb_group.wlr_group->keyboard.keymap);

	/* Here we set up listeners for keyboard events. */
	LISTEN(&keyboard->events.modifiers, &kb->modifiers, keypressmod);
	LISTEN(&keyboard->events.key, &kb->key, keypress);
	LISTEN(&keyboard->base.events.destroy, &kb->destroy, cleanupkeyboard);

	wlr_seat_set_keyboard(seat, keyboard);
	kb->key_repeat_source = wl_event_loop_add_timer(
			wl_display_get_event_loop(dpy), keyrepeat, kb);
	/* And add the keyboard to our list of keyboards */
	wl_list_insert(&keyboards, &kb->link);

	/* Add the new keyboard to the group */
	wlr_keyboard_group_add_keyboard(kb_group.wlr_group, keyboard);

	if (!wl_list_empty(&keyboards))

	if (!wl_list_empty(&kb_group.wlr_group->devices))

	Keyboard *kb = wl_container_of(listener, kb, key);

	KeyboardGroup *group = wl_container_of(listener, group, key);

			kb->wlr_keyboard->xkb_state, keycode, &syms);

			group->wlr_group->keyboard.xkb_state, keycode, &syms);

	uint32_t mods = wlr_keyboard_get_modifiers(kb->wlr_keyboard);

	uint32_t mods = wlr_keyboard_get_modifiers(&group->wlr_group->keyboard);

	if (handled && kb->wlr_keyboard->repeat_info.delay > 0) {
		kb->mods = mods;
		kb->keysyms = syms;
		kb->nsyms = nsyms;
		wl_event_source_timer_update(kb->key_repeat_source,
				kb->wlr_keyboard->repeat_info.delay);

	if (handled && group->wlr_group->keyboard.repeat_info.delay > 0) {
		group->mods = mods;
		group->keysyms = syms;
		group->nsyms = nsyms;
		wl_event_source_timer_update(group->key_repeat_source,
				group->wlr_group->keyboard.repeat_info.delay);

		kb->nsyms = 0;
		wl_event_source_timer_update(kb->key_repeat_source, 0);

		group->nsyms = 0;
		wl_event_source_timer_update(group->key_repeat_source, 0);

	wlr_seat_set_keyboard(seat, kb->wlr_keyboard);

	Keyboard *kb = wl_container_of(listener, kb, modifiers);
	/*
	 * A seat can only have one keyboard, but this is a limitation of the
	 * Wayland protocol - not wlroots. We assign all connected keyboards to the
	 * same seat. You can swap out the underlying wlr_keyboard like this and
	 * wlr_seat handles this transparently.
	 */
	wlr_seat_set_keyboard(seat, kb->wlr_keyboard);

	KeyboardGroup *group = wl_container_of(listener, group, modifiers);

		&kb->wlr_keyboard->modifiers);

		&group->wlr_group->keyboard.modifiers);

	Keyboard *kb = data;

	KeyboardGroup *group = data;

	if (!kb->nsyms || kb->wlr_keyboard->repeat_info.rate <= 0)

	if (!group->nsyms || group->wlr_group->keyboard.repeat_info.rate <= 0)

	wl_event_source_timer_update(kb->key_repeat_source,
			1000 / kb->wlr_keyboard->repeat_info.rate);

	wl_event_source_timer_update(group->key_repeat_source,
			1000 / group->wlr_group->keyboard.repeat_info.rate);

	for (i = 0; i < kb->nsyms; i++)
		keybinding(kb->mods, kb->keysyms[i]);

	for (i = 0; i < group->nsyms; i++)
		keybinding(group->mods, group->keysyms[i]);

	struct xkb_context *context;
	struct xkb_keymap *keymap;

	wl_list_init(&keyboards);

	/*
	 * Configures a keyboard group, which will keep track of all connected
	 * keyboards, keep their modifier and LED states in sync, and handle
	 * keypresses
	 */
	kb_group.wlr_group = wlr_keyboard_group_create();
	kb_group.wlr_group->data = &kb_group;
	/* Prepare an XKB keymap and assign it to the keyboard group. */
	context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
	keymap = xkb_keymap_new_from_names(context, &xkb_rules,
		XKB_KEYMAP_COMPILE_NO_FLAGS);
	if (!keymap)
		die("failed to compile keymap");
	wlr_keyboard_set_keymap(&kb_group.wlr_group->keyboard, keymap);
	xkb_keymap_unref(keymap);
	xkb_context_unref(context);
	wlr_keyboard_set_repeat_info(&kb_group.wlr_group->keyboard, repeat_rate, repeat_delay);
	/* Set up listeners for keyboard events */
	LISTEN(&kb_group.wlr_group->keyboard.events.key, &kb_group.key, keypress);
	LISTEN(&kb_group.wlr_group->keyboard.events.modifiers, &kb_group.modifiers, keypressmod);
	kb_group.key_repeat_source = wl_event_loop_add_timer(
			wl_display_get_event_loop(dpy), keyrepeat, &kb_group);

	/* A seat can only have one keyboard, but this is a limitation of the
	 * Wayland protocol - not wlroots. We assign all connected keyboards to the
	 * same wlr_keyboard_group, which provides a single wlr_keyboard interface for
	 * all of them. Set this combined wlr_keyboard as the seat keyboard.
	 */
	wlr_seat_set_keyboard(seat, &kb_group.wlr_group->keyboard);