arrange_layer(m, &m->layers[i], &usable_area, 0);

    /* Give keyboard focus to the highest layer that requests it. */

    for (i = 0; i < (int)LENGTH(layers_above_shell); i++) {

        wl_list_for_each_reverse(l, &m->layers[layers_above_shell[i]], link) {

                continue;

            /* Deactivate the focused client. */

            focus_client(nullptr, 0);

            exclusive_focus = l;

            client_notify_enter(l->layer_surface->surface, wlr_seat_get_keyboard(seat));

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

    struct wlr_pointer_button_event *event = data;

    struct wlr_keyboard             *keyboard;

    uint32_t                         mods;

    client_t                        *c;

    const button_t                  *b;

    wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);

    switch (event->state) {

        if (locked)

            break;

        /* Focus a window when a button is pressed over it. */

        if (c && (!client_is_unmanaged(c) || client_wants_focus(c)))

            focus_client(c, 1);

        keyboard = wlr_seat_get_keyboard(seat);

        mods     = keyboard ? wlr_keyboard_get_modifiers(keyboard) : 0;

        for (b = buttons; b < END(buttons); b++) {

    /* Deactivate the old window when focus changes. */

    if (old && (!c || client_surface(c) != old)) {

        /* If an overlay is focused, don't focus or activate the client,

         * but only update its position in fstack to render its border with

         * focuscolor and focus it after the overlay is closed. */

            wlr_scene_node_coords(&old_l->scene->node, &unused_lx, &unused_ly) &&

            old_l->layer_surface->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) {

            return;

        } else if (old_c && old_c == exclusive_focus && client_wants_focus(old_c)) {

            return;

    wl_signal_add(&xdg_shell->events.new_popup, &new_xdg_popup);

    xdg_dialog_mgr = wlr_xdg_wm_dialog_v1_create(dpy, 1);

    wl_signal_add(&xdg_dialog_mgr->events.new_dialog, &new_xdg_dialog);

    wl_signal_add(&layer_shell->events.new_surface, &new_layer_surface);

    idle_notifier = wlr_idle_notifier_v1_create(dpy);

    idle_inhibit_mgr = wlr_idle_inhibit_v1_create(dpy);

    WlShm,

)

from protocols.wlr_foreign_toplevel_management_unstable_v1 import (

    ZwlrForeignToplevelManagerV1,

)

from protocols.wlr_output_power_management_unstable_v1 import (

    ZwlrOutputPowerManagerV1,

)

from protocols.wlr_virtual_pointer_unstable_v1 import ZwlrVirtualPointerManagerV1

from protocols.xdg_shell import XdgPositioner, XdgToplevel, XdgWmBase

        self.display = Display()

        self.display.connect()

        self.registry = self.display.get_registry()

        self.interfaces = {interface.name: interface for interface in interfaces}

        self.globals: dict[str, object] = {}

        self.registry.dispatcher["global"] = self._global

        self.display.roundtrip()

    def _global(self, registry, name: int, interface: str, version: int) -> None:

        wanted = self.interfaces.get(interface)

        if wanted is not None and interface not in self.globals:

            self.globals[interface] = registry.bind(name, wanted, min(version, wanted.version))

    def get(self, interface):

        """Return a required bound global."""

        try:

            return self.globals[interface.name]

        except KeyError as error:

            raise Failure(f"compositor does not advertise {interface.name}") from error

    def roundtrips(self, count: int = 1) -> None:

        """Complete several request/event exchanges."""

        for _ in range(count):

            if self.display.roundtrip() < 0:

def layer(arguments: list[str]) -> None:

    """Create, configure, map, and destroy layer-shell surfaces."""

    count = int(arguments[0]) if arguments else 2

    compositor = connection.get(WlCompositor)

    shm = connection.get(WlShm)

    shell = connection.get(ZwlrLayerShellV1)

    layers = []

    for index in range(count):

        surface = compositor.create_surface()

        role = shell.get_layer_surface(

            surface,

            None,

            ZwlrLayerShellV1.layer.top,

            f"swm-layer-{index}",

        )

        configured = []

        def configure(

            proxy,

            serial,

            configured.append(True)

        role.dispatcher["configure"] = configure

        role.dispatcher["closed"] = lambda proxy: None

        role.set_size(80 + index, 40 + index)

        surface.commit()

        layers.append((surface, role, configured))

    connection.roundtrips(3)

    if not all(configured for _, _, configured in layers):

        raise Failure("layer surface was not configured")

    for surface, role, _ in reversed(layers):

        role.destroy()

        surface.destroy()

    connection.roundtrips()

    connection.close()

    struct wlr_box    box;

    char              storage[MAX_COMMAND_SIZE], *expanded[MAX_COMMAND_ARGS];

    const char *const command[] = { "before-$SWM_TEST_EXPAND", "$SWM_TEST_MISSING", nullptr };

    init_xdg_client(&client, &xdg, &toplevel, "xdg-app", "XDG title");

    client.is_fullscreen = true;

    assert(!client_allows_move_resize(&client, CURSOR_MOVE));

    assert(client_allows_move_resize(&client, CURSOR_RESIZE));

    client.is_fullscreen = false;

    assert(client_allows_move_resize(&client, CURSOR_MOVE));