output. When `-s` is used, that output is connected to the startup command's

standard input. Workspace metadata uses `workspace N title VALUE` and

`workspace N color #RRGGBBAA` records; empty values mean unset. Use

`swmctl events --filter=active-window` to receive the active window title for

a custom bar module.

# TESTING AND DEVELOPMENT

Run the complete test suite with:

    AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

    ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  </copyright>

      This interface activates mapped toplevels by the stable identifier from

    </description>

    <enum name="error">

      <entry name="invalid_identifier" value="1" summary="the toplevel identifier does not exist"/>

    </enum>

    </request>

    <request name="destroy" type="destructor">

      <description summary="destroy the manager object"/>

    </request>

  </interface>

</protocol>

    client_t *c, struct wlr_surface *surface, double sx, double sy, uint32_t time, bool refocus

);

static void         print_status(void);

static void         publish_status(void);

static void         status_idle_notify(void *data);

static void         execute_command(char *const argv[], const char *context);

static void         prepare_child(void);

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

static void         quit(const arg_t *arg);

static void         raise_client(const arg_t *arg);

/* Sanitize a field for status output, leaving an unknown value empty. */

static void status_field(char *dst, size_t size, const char *src) {

    swm_sanitize_field(dst, size, src, nullptr);

}

/* Publish the status once the current batch of changes has settled. */

void status_idle_notify(void *data) {

    status_idle = nullptr;

    publish_status();

}

        publish_status();

}

/* Publish current display, workspace, and focus state on standard output. */

void publish_status(void) {

    occ = urg = 0;

    wl_list_for_each(c, &clients, link) {

        ftl_sync(c);

        if (workspaces[i].color)

            printf("workspace %d color #%08" PRIx32 "\n", i + 1, workspaces[i].color);

        else

            printf("workspace %d color \n", i + 1);

    }

    fflush(stdout);

    workspace_broadcast();

}

/* Replace a command child with its program or an error notification. */

        "toplevel identifier '%s' does not exist",

        identifier

    );

}

/* Release a toplevel control manager. */

static void toplevel_control_destroy(struct wl_client *client, struct wl_resource *resource) {

    wl_resource_destroy(resource);

}

static const struct swm_toplevel_manager_v1_interface toplevel_control_impl = {

};

/* Publish swm's toplevel control interface to a client. */

static void toplevel_control_bind(

    struct wl_client *client, void *data, uint32_t version, uint32_t id

    wl_list_init(&window_states);

    wl_list_init(&input_popups);

    load_window_states();

    wl_global_create(dpy, &ext_workspace_manager_v1_interface, 1, nullptr, workspace_manager_bind);

    wl_global_create(dpy, &swm_workspace_manager_v1_interface, 1, nullptr, workspace_metadata_bind);

    /* Publish window lists for taskbars and switchers. */

    ftl_mgr      = wlr_foreign_toplevel_manager_v1_create(dpy);

    ext_ftl_list = wlr_ext_foreign_toplevel_list_v1_create(dpy, 1);

    wlr_ext_image_copy_capture_manager_v1_create(dpy, 1);

*swmctl workspace clear* _N_ (*title*|*color*)

*swmctl workspace subscribe* [*--format=waybar*]

*swmctl events --filter=active-window*

== DESCRIPTION

*swmctl* connects to the running *swm* Wayland compositor and reads or changes

*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.

== WAYBAR

The `ext/workspaces` module continues to display the numeric workspace names

`1` through `10`. A custom module can display the additional title and color

independently:

/* Wayland globals required by one command family. */

enum command_kind {

    COMMAND_WORKSPACE,

    COMMAND_WINDOW_LIST,

    COMMAND_WINDOW_ACTIVATE,

    COMMAND_EVENTS,

};

/* Cached state for one ext-foreign-toplevel handle. */

typedef struct {

static struct wl_display                   *display;

static struct swm_workspace_manager_v1     *manager;

static struct ext_foreign_toplevel_list_v1 *toplevel_list;

static struct swm_toplevel_manager_v1      *toplevel_control;

static struct wl_list                       windows;

static workspace_t                          workspaces[MAX_WORKSPACES];

static bool                                 subscribing;

static bool                                 waybar;

static bool                                 toplevel_list_finished;

        "  swmctl workspace set N (title TITLE | color COLOR)\n"

        "  swmctl workspace clear N (title | color)\n"

        "  swmctl workspace subscribe [--format=waybar]\n"

        "  swmctl window list\n"

        "  swmctl window activate IDENTIFIER\n"

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

    );

    exit(EXIT_FAILURE);

}

    ) {

        toplevel_list =

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

        ext_foreign_toplevel_list_v1_add_listener(toplevel_list, &window_list_listener, nullptr);

    } else if (

        !strcmp(interface, swm_toplevel_manager_v1_interface.name)

    ) {

    } else if (

        requested_kind == COMMAND_EVENTS &&

        !strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name)

    ) {

        event_manager =

        putchar('\t');

        puts(window->identifier);

    }

}

/* Release cached foreign-toplevel state. */

static void destroy_windows(void) {

    window_t *window, *tmp;

    wl_list_for_each_safe(window, tmp, &windows, link) {

    registry       = wl_display_get_registry(display);

    wl_registry_add_listener(registry, &registry_listener, nullptr);

    if (wl_display_roundtrip(display) < 0 || (kind == COMMAND_WORKSPACE && !manager) ||

        (kind == COMMAND_WINDOW_LIST && !toplevel_list) ||

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

        fprintf(

            stderr,

            kind == COMMAND_WORKSPACE ? "swmctl: compositor does not support swm-workspace-v1\n"

            : kind == COMMAND_WINDOW_LIST

                ? "swmctl: compositor does not support ext-foreign-toplevel-list-v1\n"

            : kind == COMMAND_EVENTS

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

                : "swmctl: compositor does not support swm-toplevel-v1\n"

        );

        exit(EXIT_FAILURE);

    }

    if (kind != COMMAND_WINDOW_ACTIVATE && wl_display_roundtrip(display) < 0) {

                usage();

        } else if (!strcmp(command, "activate")) {

            if (argc != 4)

                usage();

            identifier = argv[3];

        } else {

            usage();

        }

    } else if (strcmp(argv[1], "workspace")) {

        usage();

            usage();

    } else {

        usage();

    }

    connect_manager(

    );

    if (window_command) {

        if (!strcmp(command, "list"))

            print_windows();

            swm_toplevel_manager_v1_activate(toplevel_control, identifier);

    } else if (subscribing) {

        while (wl_display_dispatch(display) >= 0)

            ;

        return EXIT_FAILURE;

    connection = Connection(WlCompositor, WlShm, XdgWmBase)

    window = Window(connection, "output-float", 0xFF336699, fixed_size=True)

    connection.roundtrips(4)

    def geometry() -> tuple[int, ...]:

        window.toplevel.set_title("output-float")

        connection.roundtrips(3)

        match = re.search(r"^(-?\d+),(-?\d+) (\d+)x(\d+) output-float$", contents, re.MULTILINE)

        if not match:

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

    before = geometry()

    subprocess.run(["wlr-randr", "--output", "HEADLESS-1", "--pos", "100,80"], check=True)

    moved = geometry()

    path = Path(os.environ["SWM_TEST_DIR"]) / f"{name}.geometry"

    return list(map(int, path.read_text().split()))

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

    match = re.search(

    )

    if not match:

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

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

    start_title_events()

    one = start_client("one", "ff5588dd")

    two = start_client("two", "ff55aa88")

    def publication() -> None:

        if not re.search(r"^\d+,\d+ \d+x\d+ one$", windows, re.MULTILINE):

            raise Failure("missing published rectangle for one")

        if not re.search(r"^\d+,\d+ \d+x\d+ two$", windows, re.MULTILINE):

            raise Failure("missing published rectangle for two")

        before = current_title()

        virtual_keyboard(36)

        wait_title("two" if before == "one" else "one")

    def active_window_events() -> None:

        title = current_title()

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

        subscriber = spawn(

    unsetenv("SWM_TEST_MISSING");

    expand_argv(command, expanded, storage);

    assert(!strcmp(expanded[0], "before-expanded value"));

    assert(!strcmp(expanded[1], ""));

    assert(expanded[2] == nullptr);

}

/* Verify configured autostart commands and child tracking with harmless stubs. */

static void test_autostart_execution(void) {

    const char     *stub_path = getenv("SWM_TEST_STUB_PATH");