/* Apply a Wayland window's initial state or committed geometry. */

    struct wlr_box geom, old_geom;

    old_geom = c->geom;

    /* Floating applications may choose their own size. Applications may also

     * round a compositor-requested size. Match the frame to the committed

     * window geometry in both cases. */

    if (!c->is_fullscreen && (c->resize || c->is_floating)) {

    } else if (c->is_floating && !c->is_fullscreen && c->mon) {

        /* Bound floating windows by the whole layout, as resize() does for an

         * interactive move. A window dragged onto a neighbouring display keeps

         * its display until the drag ends, so bounding it by that display's

         * usable area would snap it back on the next commit. */

        apply_bounds(c, &sgeom);

        resize_apply(c);

    if (c->mon && !wlr_box_equal(&old_geom, &c->geom)) {

        print_status();

        /* The window moved under a stationary pointer. Recheck pointer focus,

         * as arrange() does, so scroll and button events reach the surface now

         * beneath the cursor. Keep any input popups with their window. */

        motion_notify(0, nullptr, 0, 0, 0, 0, 1);

        if (c == focus_top(c->mon))

            position_input_popups();

    }

    wl_list_for_each(c, &clients, link) {

        if (!c->mon || !client_surface(c)->mapped || !c->scene->node.enabled)

            continue;

        status_field(title, sizeof(title), client_get_title(c));

        fprintf(

            file, "%d,%d %dx%d %s\n", c->geom.x, c->geom.y, c->geom.width, c->geom.height, title

        );

        fixed_size: bool = False,

        if fixed_size:

            self.toplevel.set_min_size(self.width, self.height)

            self.toplevel.set_max_size(self.width, self.height)

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

    """Commit a client-selected size after an XDG window maps.

    The window maps with fixed size limits so the compositor cannot choose its

    initial size, then drops those limits and commits each requested size on

    its own once the runner triggers it.

    """

    if len(arguments) != 4:

        raise Failure("xdg-resize requires WIDTH HEIGHT WIDTH HEIGHT")

    trigger = Path(os.environ["SWM_RESIZE_TRIGGER"])

    committed = Path(os.environ["SWM_RESIZE_COMMITTED"])

    connection = Connection(WlCompositor, WlShm, XdgWmBase)

    window = Window(

        connection,

        "client-resize",

        0xFF336699,

        fixed_size=True,

        report=Path(os.environ["SWM_CLIENT_REPORT"]),

    )

    connection.roundtrips(3)

    # The window mapped at a size the compositor could not override. Unlock the

    # size limits so later commits choose their own size the way an application

    # that resizes itself does.

    window.toplevel.set_min_size(0, 0)

    window.toplevel.set_max_size(0, 0)

    window.surface.commit()

    connection.roundtrips(2)

    for index in range(2):

        deadline = time.monotonic() + 5

        while not trigger.exists() or trigger.read_text().strip() != str(index):

            if time.monotonic() >= deadline:

                raise Failure(f"timed out waiting for resize trigger {index}")

            time.sleep(0.01)

        window.width = int(arguments[index * 2])

        window.height = int(arguments[index * 2 + 1])

        window.xdg_surface.set_window_geometry(0, 0, window.width, window.height)

        window.draw()

        connection.display.flush()

        committed.write_text(f"{index}\n")

    while window.running:

        connection.display.dispatch(block=True)

    window.destroy()

    connection.close()

    "xdg-resize": xdg_resize,

def consistently(description: str, predicate, duration: float = 0.5):

    """Fail if a predicate stops holding within a duration."""

    deadline = time.monotonic() + duration

    while time.monotonic() < deadline:

        if not predicate():

            raise Failure(f"{description} did not hold")

        time.sleep(0.02)

def published_geometry(title: str) -> list[int]:

    """Return a client's compositor-published outer geometry."""

    path = Path(os.environ["XDG_RUNTIME_DIR"]) / "swm-windows"

    match = re.search(

        rf"^(\d+),(\d+) (\d+)x(\d+) {re.escape(title)}$", path.read_text(), re.MULTILINE

    )

    if not match:

        raise Failure(f"missing published geometry for {title}")

    return list(map(int, match.groups()))

        windows = (Path(os.environ["XDG_RUNTIME_DIR"]) / "swm-windows").read_text()

    def client_resize() -> None:

        report = Path(os.environ["SWM_TEST_DIR"]) / "client-resize.geometry"

        trigger = Path(os.environ["SWM_TEST_DIR"]) / "client-resize.trigger"

        committed = Path(os.environ["SWM_TEST_DIR"]) / "client-resize.committed"

        env = os.environ.copy()

        env["SWM_CLIENT_REPORT"] = str(report)

        env["SWM_RESIZE_TRIGGER"] = str(trigger)

        env["SWM_RESIZE_COMMITTED"] = str(committed)

        targets = ([200, 120], [520, 320])

        client = spawn(

            client_log("client-resize"),

            *client_command("xdg-resize", *targets[0], *targets[1]),

            env=env,

        )

        wait_title("client-resize")

        eventually("client resize report", lambda: report.exists() and report.stat().st_size)

        def border_size():

            configured = geometry("client-resize")

            outer = published_geometry("client-resize")

            delta = [outer[2] - configured[0], outer[3] - configured[1]]

            return delta if delta[0] == delta[1] and delta[0] >= 0 else None

        border = eventually("settled floating geometry", border_size)

        for index, target in enumerate(targets):

            trigger.write_text(f"{index}\n")

            eventually(

                f"client resize commit {index}",

                lambda index=index: committed.exists()

                and committed.read_text().strip() == str(index),

            )

            expected = [target[0] + border[0], target[1] + border[1]]

            eventually(

                f"client-selected floating size {index}",

                lambda expected=expected: published_geometry("client-resize")[2:] == expected,

            )

            consistently(

                f"client-selected floating size {index}",

                lambda expected=expected: published_geometry("client-resize")[2:] == expected,

            )

        terminate(client)

    test("client-selected floating resize", client_resize)