struct wlr_keyboard_group      *wlr_group;

    bool                            is_virtual;

    struct wlr_virtual_keyboard_v1 *virtual_keyboard; /* Source of a virtual 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;

    uint32_t                        handled_keys[(KEY_CNT + 31) / 32];

    struct wl_listener              modifiers;

    struct wl_listener              key;

    struct wl_listener              destroy;

/* Select the input-method grab for a keyboard's events. */

static struct wlr_input_method_keyboard_grab_v2 *input_method_grab(keyboard_group_t *group) {

    if (locked || !input_method || !input_method->keyboard_grab)

        return nullptr;

    if (group->virtual_keyboard && wl_resource_get_client(group->virtual_keyboard->resource) ==

                                       wl_resource_get_client(input_method->resource))

        return nullptr;

    return input_method->keyboard_grab;

}

/* Handle shortcuts and send unhandled keys to the input recipient. */

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

    struct wlr_keyboard_key_event            *event = data;

    struct wlr_input_method_keyboard_grab_v2 *grab;

    /* Send unhandled keys to the input method or focused application. */

    if ((grab = input_method_grab(group))) {

        wlr_input_method_keyboard_grab_v2_set_keyboard(grab, &group->wlr_group->keyboard);

        wlr_input_method_keyboard_grab_v2_send_key(

            grab, event->time_msec, event->keycode, event->state

        );

    } else

        wlr_seat_keyboard_notify_key(seat, event->time_msec, event->keycode, event->state);

/* Send a keyboard's modifier state to the input recipient. */

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

    struct wlr_input_method_keyboard_grab_v2 *grab;

    /* Send modifiers to the input method or focused application. */

    if ((grab = input_method_grab(group))) {

        wlr_input_method_keyboard_grab_v2_set_keyboard(grab, &group->wlr_group->keyboard);

        wlr_input_method_keyboard_grab_v2_send_modifiers(

            grab, &group->wlr_group->keyboard.modifiers

        );

    } else

        wlr_seat_keyboard_notify_modifiers(seat, &group->wlr_group->keyboard.modifiers);

    group->virtual_keyboard = kb;

def input_method_keys() -> None:

    """Check keyboard grabs and input-method key reinjection."""

    connection = Connection(

        WlCompositor, WlShm, WlSeat, XdgWmBase,

        ZwpInputMethodManagerV2, ZwpVirtualKeyboardManagerV1,

    )

    seat = connection.get(WlSeat)

    virtual = connection.get(ZwpVirtualKeyboardManagerV1).create_virtual_keyboard(seat)

    keymap, indices = keymap_text()

    with tempfile.TemporaryFile(dir=os.environ.get("SWM_TEST_DIR")) as stream:

        stream.write(keymap + b"\0")

        stream.flush()

        virtual.keymap(WlKeyboard.keymap_format.xkb_v1, stream.fileno(), len(keymap) + 1)

    connection.roundtrips()

    keyboard = seat.get_keyboard()

    app_keys = []

    keyboard.dispatcher["key"] = lambda proxy, serial, time, key, state: app_keys.append((key, state))

    window = Window(connection, "input-method-keys", 0xFF556677)

    connection.roundtrips(4)

    method = connection.get(ZwpInputMethodManagerV2).get_input_method(seat)

    grab = method.grab_keyboard()

    grabbed_keys = []

    grabbed_modifiers = []

    grab.dispatcher["keymap"] = lambda proxy, format, fd, size: os.close(fd)

    grab.dispatcher["key"] = lambda proxy, serial, time, key, state: grabbed_keys.append((key, state))

    grab.dispatcher["modifiers"] = lambda proxy, serial, depressed, latched, locked, group: (

        grabbed_modifiers.append(depressed)

    )

    connection.roundtrips(2)

    subprocess.run([sys.executable, __file__, "keyboard", "30", "1"], check=True)

    connection.roundtrips(2)

    if (30, 1) not in grabbed_keys or (30, 0) not in grabbed_keys:

        raise Failure("input method did not receive the grabbed key")

    if not any(grabbed_modifiers):

        raise Failure("input method did not receive Shift")

    if app_keys:

        raise Failure("grabbed keys reached the application")

    count = len(grabbed_keys)

    virtual.modifiers(1 << indices["shift"], 0, 0, 0)

    virtual.key(3, 30, 1)

    virtual.key(4, 30, 0)

    virtual.modifiers(0, 0, 0, 0)

    connection.roundtrips(2)

    if app_keys != [(30, 1), (30, 0)] or len(grabbed_keys) != count:

        raise Failure("input-method keys did not reach the application directly")

    grab.release()

    connection.roundtrips()

    app_keys.clear()

    subprocess.run([sys.executable, __file__, "keyboard", "48", "0"], check=True)

    connection.roundtrips(2)

    if app_keys != [(48, 1), (48, 0)]:

        raise Failure("keyboard input did not resume after the grab ended")

    method.destroy()

    window.destroy()

    virtual.destroy()

    connection.close()

    input_method_keys()