wlr-foreign-toplevel-management-unstable-v1-protocol.o \

		wlr-foreign-toplevel-management-unstable-v1-client-protocol.h \

wlr-foreign-toplevel-management-unstable-v1-client-protocol.h: \

		protocols/wlr-foreign-toplevel-management-unstable-v1.xml

	@echo "hdr  $@"

	@$(WL_SCANNER) client-header $< $@

wlr-foreign-toplevel-management-unstable-v1-protocol.c: \

		protocols/wlr-foreign-toplevel-management-unstable-v1.xml

	@echo "src  $@"

	@$(WL_SCANNER) private-code $< $@

		wlr-foreign-toplevel-management-unstable-v1-client-protocol.h \

		ext-foreign-toplevel-list-v1-protocol.c \

		wlr-foreign-toplevel-management-unstable-v1-protocol.c swm-toplevel-v1-protocol.c \

		ext-foreign-toplevel-list-v1-protocol.c \

		wlr-foreign-toplevel-management-unstable-v1-protocol.c swm-toplevel-v1-protocol.c \

		wlr-foreign-toplevel-management-unstable-v1-client-protocol.h \

		ext-foreign-toplevel-list-v1-protocol.c \

		wlr-foreign-toplevel-management-unstable-v1-protocol.c swm-toplevel-v1-protocol.c \

		ext-foreign-toplevel-list-v1-protocol.c \

		wlr-foreign-toplevel-management-unstable-v1-protocol.c swm-toplevel-v1-protocol.c \

swmctl - inspect swm state and change workspace metadata

*swmctl events --filter=active-window*

*events --filter=active-window* writes the current active window title, then

writes a new line when the active window or its title changes. It writes an

empty line when no window is active. Control characters in titles become spaces.

The command stays connected until it is stopped or the compositor exits.

To show the active window title in Waybar, use:

    "modules-center": ["custom/swm-window"],

    "custom/swm-window": {

        "exec": "swmctl events --filter=active-window",

        "max-length": 80,

        "tooltip": false

    }

#include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"

    COMMAND_EVENTS,

/* Cached title and activation state for one event-stream toplevel. */

typedef struct {

    struct wl_list link;

    char          *title;

    bool           active;

    bool           ready;

} event_window_t;

static struct zwlr_foreign_toplevel_manager_v1 *event_manager;

static struct wl_list                           event_windows;

static event_window_t                          *previous_event_window;

static char                                    *previous_event_title;

static bool                                     event_published;

        "  swmctl events --filter=active-window\n"

/* Cache a toplevel title for the active-window event stream. */

static void event_title(

    void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, const char *title

) {

    event_window_t *window = data;

    replace_string(&window->title, title);

    window->ready = false;

}

static void event_app_id(

    void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, const char *app_id

) {}

static void event_output(

    void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, struct wl_output *output

) {}

static void event_parent(

    void                                   *data,

    struct zwlr_foreign_toplevel_handle_v1 *handle,

    struct zwlr_foreign_toplevel_handle_v1 *parent

) {}

/* Cache whether a toplevel is active. */

static void event_state(

    void *data, struct zwlr_foreign_toplevel_handle_v1 *handle, struct wl_array *state

) {

    event_window_t *window = data;

    uint32_t       *value;

    window->active = false;

    window->ready  = false;

    wl_array_for_each(value, state) {

        if (*value == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED)

            window->active = true;

    }

}

/* Mark a complete toplevel update ready for publication. */

static void event_done(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) {

    event_window_t *window = data;

    window->ready = true;

}

/* Release a closed toplevel and invalidate its last published identity. */

static void event_closed(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) {

    event_window_t *window = data;

    zwlr_foreign_toplevel_handle_v1_destroy(handle);

    if (window == previous_event_window) {

        previous_event_window = nullptr;

        event_published       = false;

    }

    wl_list_remove(&window->link);

    free(window->title);

    free(window);

}

static const struct zwlr_foreign_toplevel_handle_v1_listener event_window_listener = {

    .title        = event_title,

    .app_id       = event_app_id,

    .output_enter = event_output,

    .output_leave = event_output,

    .state        = event_state,

    .done         = event_done,

    .closed       = event_closed,

    .parent       = event_parent,

};

/* Track a new toplevel for active-window updates. */

static void event_toplevel(

    void                                    *data,

    struct zwlr_foreign_toplevel_manager_v1 *object,

    struct zwlr_foreign_toplevel_handle_v1  *handle

) {

    event_window_t *window = calloc(1, sizeof(*window));

    if (!window) {

        fprintf(stderr, "swmctl: out of memory\n");

        exit(EXIT_FAILURE);

    }

    wl_list_insert(event_windows.prev, &window->link);

    zwlr_foreign_toplevel_handle_v1_add_listener(handle, &event_window_listener, window);

}

static void event_finished(void *data, struct zwlr_foreign_toplevel_manager_v1 *object) {

    event_manager = nullptr;

}

static const struct zwlr_foreign_toplevel_manager_v1_listener event_manager_listener = {

    .toplevel = event_toplevel,

    .finished = event_finished,

};

/* Write one title as a single line suitable for a Waybar custom module. */

static void print_event_title(const char *title) {

    const unsigned char *p;

    for (p = (const unsigned char *)title; *p; p++)

        putchar(*p < ' ' || *p == 0x7f ? ' ' : *p);

    putchar('\n');

    fflush(stdout);

}

/* Publish the active title after a complete batch of Wayland events. */

static void publish_active_window(void) {

    event_window_t *window, *active = nullptr;

    const char     *title;

    wl_list_for_each(window, &event_windows, link) {

        if (!window->ready)

            return;

        if (window->active)

            active = window;

    }

    title = active && active->title ? active->title : "";

    if (event_published && active == previous_event_window && !strcmp(title, previous_event_title))

        return;

    replace_string(&previous_event_title, title);

    previous_event_window = active;

    event_published       = true;

    print_event_title(title);

}

    } else if (

        requested_kind == COMMAND_EVENTS &&

        !strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name)

    ) {

        event_manager =

            wl_registry_bind(registry, name, &zwlr_foreign_toplevel_manager_v1_interface, 1);

        zwlr_foreign_toplevel_manager_v1_add_listener(

            event_manager, &event_manager_listener, nullptr

        );

    wl_list_init(&event_windows);

        (kind == COMMAND_WINDOW_ACTIVATE && !toplevel_control) ||

        (kind == COMMAND_EVENTS && !event_manager)) {

            : kind == COMMAND_EVENTS

                ? "swmctl: compositor does not support wlr-foreign-toplevel-management-v1\n"

    if (!strcmp(argv[1], "events")) {

        if (argc != 3 || strcmp(argv[2], "--filter=active-window"))

            usage();

        connect_manager(COMMAND_EVENTS);

        publish_active_window();

        while (wl_display_dispatch(display) >= 0)

            publish_active_window();

        return EXIT_FAILURE;

    }

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

    """Change a mapped window title when the runner requests it."""

    if len(arguments) != 2:

        raise Failure("xdg-title-change requires INITIAL CHANGED")

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

    connection = Connection(WlCompositor, WlShm, XdgWmBase)

    window = Window(connection, arguments[0], 0xFF336699)

    connection.roundtrips(3)

    deadline = time.monotonic() + 5

    while not trigger.exists():

        if time.monotonic() >= deadline:

            raise Failure("timed out waiting for title trigger")

        time.sleep(0.01)

    window.toplevel.set_title(arguments[1])

    window.surface.commit()

    connection.display.flush()

    while window.running:

        connection.display.dispatch(block=True)

    window.destroy()

    connection.close()

    "xdg-title-change": xdg_title_change,

#define _POSIX_C_SOURCE 200809L

/* Verify active-window updates and single-line title output. */

static void test_active_window_events(void) {

    event_window_t first       = { .title = "one", .active = true, .ready = true };

    event_window_t second      = { .title = "two", .ready = true };

    char           output[128] = { 0 };

    FILE          *capture     = tmpfile();

    int            saved;

    assert(capture && fflush(stdout) == 0);

    saved = dup(STDOUT_FILENO);

    assert(saved >= 0 && dup2(fileno(capture), STDOUT_FILENO) >= 0);

    wl_list_init(&event_windows);

    wl_list_insert(event_windows.prev, &first.link);

    wl_list_insert(event_windows.prev, &second.link);

    publish_active_window();

    publish_active_window();

    second.title = "renamed";

    publish_active_window();

    first.title = "one\nchanged";

    first.ready = false;

    publish_active_window();

    first.ready = true;

    publish_active_window();

    first.active  = false;

    second.active = true;

    publish_active_window();

    second.active = false;

    publish_active_window();

    assert(dup2(saved, STDOUT_FILENO) >= 0);

    close(saved);

    rewind(capture);

    assert(fread(output, 1, sizeof(output) - 1, capture) > 0);

    assert(!strcmp(output, "one\none changed\nrenamed\n\n"));

    fclose(capture);

}

    test_active_window_events();

    def active_window_events() -> None:

        title = current_title()

        log = client_log("active-window-events")

        subscriber = spawn(

            log,

            BIN / "swmctl",

            "events",

            "--filter=active-window",

            env=os.environ.copy(),

        )

        eventually("initial active-window event", lambda: log.read_text().splitlines() == [title])

        virtual_keyboard(36)

        next_title = "two" if title == "one" else "one"

        wait_title(next_title)

        eventually("changed active-window event", lambda: log.read_text().splitlines()[-1] == next_title)

        trigger = Path(os.environ["SWM_TEST_DIR"]) / "active-window-title.trigger"

        env = os.environ.copy()

        env["SWM_TITLE_TRIGGER"] = str(trigger)

        window = spawn(

            client_log("active-window-title"),

            *client_command("xdg-title-change", "initial-title", "changed-title"),

            env=env,

        )

        wait_title("initial-title")

        eventually("new active-window event", lambda: log.read_text().splitlines()[-1] == "initial-title")

        trigger.write_text("change\n")

        wait_title("changed-title")

        eventually("active title change", lambda: log.read_text().splitlines()[-1] == "changed-title")

        terminate(window)

        eventually("focus after title client closes", lambda: current_title() in {"one", "two"})

        eventually("active window after close", lambda: log.read_text().splitlines()[-1] == current_title())

        terminate(subscriber)

    test("active-window events", active_window_events)