# BARS AND STATUS

swm has no built-in bar. A layer-shell bar such as Waybar[2] can use the

On each state change swm also writes line-oriented status records to standard

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. The active window

#include <wlr/types/wlr_xdg_activation_v1.h>

#include <wlr/types/wlr_xdg_decoration_v1.h>

#include <wlr/types/wlr_xdg_dialog_v1.h>

#include <wlr/types/wlr_xdg_output_v1.h>

#include <wlr/types/wlr_xdg_shell.h>

#include <wlr/types/wlr_xdg_system_bell_v1.h>

#include <wlr/util/log.h>

#include <wlr/util/region.h>

#include <wlr/xwayland.h>

#include <xcb/xcb.h>

#include <xcb/xcb_icccm.h>

#define MAX_WINDOW_STATE_FIELD  256

#define MAX_STATUS_FIELD        1024

#define MAX_WINDOW_STATE_LINE   1024

#define MAX_STATE_PATH          4096

#define MAX_WORKSPACE_TITLE     256

#define MAX_STATIC_LISTENERS    128

#define MAX_GLOBAL_LISTENERS    64

#define MAX_WS_MANAGERS         64

#define MAX_AUTOSTART           64

#define MAX_COMMAND_SIZE        1024

#define MAX_COMMAND_ARGS        64

/* Cursor interaction state. */

/* Display and its window-manager state. */

typedef struct monitor_t monitor_t;

/* Global workspace state. */

typedef struct workspace_t workspace_t;

/* Managed XDG or Xwayland client. */

typedef struct {

    /* This must remain first so generic surface code can read it. */

    unsigned int type; /* XDG_SHELL or X11. */

    const layout_t *prevlt;

    stack_state_t   v, h;

    struct wl_list  handles; /* Protocol handles that publish this workspace. */

};

/* Bound ext-workspace manager. */

typedef struct {

} workspace_manager_t;

/* Exported ext-workspace handle. */

typedef struct {

    struct wl_resource  *resource;

    workspace_t         *ws;

} workspace_handle_t;

/* Bound client for swm's ephemeral workspace metadata protocol. */

typedef struct {

    struct wl_resource *resource;

);

static void toplevel_control_bind(

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

);

static void workspace_metadata_broadcast(void);

static void workspace_manager_bind(

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

);

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

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

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

static void       setup(void);

static void       spawn(const arg_t *arg);

static void       expand_argv(const char *const *argv, char **expanded, char *storage);

POOL(session_lock, session_lock_t, MAX_SESSION_LOCKS);

POOL(pending_spawn, pending_spawn_t, MAX_PENDING_SPAWNS);

POOL(window_state, window_state_t, MAX_WINDOW_STATES);

POOL(static_listener, static_listener_t, MAX_STATIC_LISTENERS);

POOL(workspace_manager, workspace_manager_t, MAX_WS_MANAGERS);

POOL(workspace_handle, workspace_handle_t, MAX_WS_HANDLES);

POOL(metadata_manager, metadata_manager_t, MAX_WS_MANAGERS);

/* Backend-specific client operations. */

/* Client helpers shared by the XDG shell and Xwayland implementations. These

            wlr_layer_surface_v1_destroy(l->layer_surface);

    }

    wl_list_remove(&m->destroy.link);

    wl_list_remove(&m->frame.link);

    wl_list_remove(&m->link);

    wl_list_remove(&m->request_state.link);

    wl_list_remove(&m->output_bind.link);

    if (m->lock_surface)

        destroy_lock_surface(&m->destroy_lock_surface, nullptr);

    LISTEN(&wlr_output->events.destroy, &m->destroy, cleanup_monitor);

    LISTEN(&wlr_output->events.request_state, &m->request_state, request_monitor_state);

    LISTEN(&wlr_output->events.bind, &m->output_bind, workspace_output_bind);

    wl_list_insert(&mons, &m->link);

    print_status();

    /* Hide unrelated content behind a transparent fullscreen window, as the

     * XDG shell protocol requires. */

    /* update_monitors() will set the final size and position. */

    wl_resource_set_implementation(resource, &toplevel_control_impl, nullptr, nullptr);

}

/*

 * ext-workspace-v1 implementation. wlroots 0.19 ships no helper for this

 */

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

    workspace_manager_t *mgr = wl_resource_get_user_data(resource);

    workspace_t         *ws;

        return;

}

/* Stop publishing workspaces to a manager. */

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

    ext_workspace_manager_v1_send_finished(resource);

};

/* Stop publishing workspaces after a manager client disconnects. */

static void workspace_manager_destroy(struct wl_resource *resource) {

    workspace_manager_t *mgr = wl_resource_get_user_data(resource);

    int                  i;

    if (!mgr)

        return;

    for (i = 0; i < WSCOUNT; i++) {

        wl_list_for_each(h, &workspaces[i].handles, link) {

            if (h->mgr == mgr)

                h->mgr = nullptr;

        }

    }

    wl_list_remove(&mgr->link);

    pool_release(&workspace_manager_pool, mgr);

}

/* Reject a client-created workspace. */

    struct wl_client *client, struct wl_resource *resource, const char *name

) {

    /* Ignore creation because swm has a fixed set of workspaces. */

}

static void workspace_group_destroy_request(

    struct wl_client *client, struct wl_resource *resource

) {

    wl_resource_destroy(resource);

}

static const struct ext_workspace_group_handle_v1_interface ws_group_impl = {

    .create_workspace = workspace_group_create_workspace,

    .destroy          = workspace_group_destroy_request,

};

static void workspace_group_destroy(struct wl_resource *resource) {

}

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

    workspace_handle_t *h = wl_resource_get_user_data(resource);

}

/* Ignore workspace deactivation. */

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

    /* Ignore deactivation because swm always has an active workspace. */

/* Ignore client workspace assignment. */

static void workspace_assign(

    struct wl_client *client, struct wl_resource *resource, struct wl_resource *group

) {

}

/* Ignore client workspace removal. */

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

    /* Ignore removal because swm has a fixed set of workspaces. */

static void workspace_handle_destroy(struct wl_resource *resource) {

    workspace_handle_t *h = wl_resource_get_user_data(resource);

    if (!h)

        return;

    wl_list_remove(&h->link);

    pool_release(&workspace_handle_pool, h);

}

    workspace_handle_t *h = pool_take(&workspace_handle_pool);

    uint32_t            coord;

    struct wl_array     coords = { sizeof(coord), sizeof(coord), &coord };

    char                id[MAX_WS_ID];

    if (!h) {

        wl_client_post_no_memory(wl_resource_get_client(mgr->resource));

        return;

    }

    h->ws       = ws;

    h->mgr      = mgr;

    h->resource = wl_resource_create(

        wl_resource_get_client(mgr->resource), &ext_workspace_handle_v1_interface, 1, 0

    );

    if (!h->resource) {

        wl_client_post_no_memory(wl_resource_get_client(mgr->resource));

        return;

    }

    wl_resource_set_implementation(h->resource, &ws_handle_impl, h, workspace_handle_destroy);

    wl_list_insert(&ws->handles, &h->link);

    ext_workspace_manager_v1_send_workspace(mgr->resource, h->resource);

    ext_workspace_handle_v1_send_name(h->resource, ws->name);

    coord = (uint32_t)ws->idx;

    ext_workspace_handle_v1_send_coordinates(h->resource, &coords);

    ext_workspace_handle_v1_send_capabilities(

        h->resource, EXT_WORKSPACE_HANDLE_V1_WORKSPACE_CAPABILITIES_ACTIVATE

    );

}

void workspace_manager_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id) {

    workspace_manager_t *mgr = pool_take(&workspace_manager_pool);

    monitor_t           *m;

    if (!mgr) {

        wl_client_post_no_memory(client);

        return;

    }

    mgr->resource =

        wl_resource_create(client, &ext_workspace_manager_v1_interface, (int)version, id);

    if (!mgr->resource) {

        pool_release(&workspace_manager_pool, mgr);

        wl_client_post_no_memory(client);

        return;

    }

    wl_resource_set_implementation(mgr->resource, &ws_manager_impl, mgr, workspace_manager_destroy);

    wl_list_insert(&ws_managers, &mgr->link);

    }

        }

    }

}

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

    struct wlr_output_event_bind *event  = data;

    struct wl_client             *client = wl_resource_get_client(event->resource);

    workspace_manager_t          *mgr;

    wl_list_for_each(mgr, &ws_managers, link) {

        }

    }

}

    _Static_assert(

        (unsigned int)SWM_WORKSPACE_ACTIVE == (unsigned int)EXT_WORKSPACE_HANDLE_V1_STATE_ACTIVE,

        "workspace active bit changed"

    );

    _Static_assert(

        if (c->ws != ws)

            continue;

        occupied  = 1;

        urgent   |= c->is_urgent;

    }

    return state;

}

void workspace_broadcast(void) {

    workspace_manager_t *mgr;

    workspace_handle_t  *h;

    int                  i;

    if (!wl_list_empty(&ws_managers)) {

        for (i = 0; i < WSCOUNT; i++) {

        }

        wl_list_for_each(mgr, &ws_managers, link) ext_workspace_manager_v1_send_done(mgr->resource);

    }

    workspace_metadata_broadcast();

}

        "return-type": "json",

        "escape": false,

        "hide-empty-text": true

    }

The custom module follows the workspace on swm's selected output and uses its

color for the title text.

== EXAMPLES

    workspaces[target].activate()

    manager.commit()

    connection.roundtrips(2)

    connection.close()

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

    """Turn one output off and back on through output-power-v1."""

    connection = Connection(WlOutput, ZwlrOutputPowerManagerV1)

    "transient": transient,

    "keyboard": keyboard,

    "pointer": pointer,

    "foreign": foreign,

    "workspace": workspace,

    "output-power": output_power,

    "output-management": output_management,

    "layer": layer,

    "session-lock": session_lock,

    "text-input": text_input,

    """Exercise workspace movement and output removal."""

    client = start_client("multi", "ff778899")

    def multioutput() -> None:

        virtual_keyboard(105, 1)

        wait_title("")

        virtual_keyboard(106, 1)

        wait_title("multi")

        virtual_keyboard(105, 4)

        protocol("output-management", "configure-second")

        protocol("output-management", "disable-second")

        wait_title("multi")

        protocol("output-management", "enable-second")

        wait_title("multi")

        virtual_keyboard(106, 4)

        wait_title("")

        virtual_keyboard(106, 1)

        wait_title("multi")

    test_pool(&session_lock_pool);

    test_pool(&pending_spawn_pool);

    test_pool(&window_state_pool);

    test_pool(&static_listener_pool);

    test_pool(&workspace_manager_pool);

    test_pool(&workspace_handle_pool);

    test_pool(&metadata_manager_pool);

}

/* Require a geometry helper to return the expected rectangle. */

/* Verify free-workspace selection and published workspace states. */

static void test_workspace_queries(void) {

    client_t    *client;

    workspace_t *workspace;

    int          i;

    for (i = 0; i < WSCOUNT; i++) {

        wl_list_init(&workspaces[i].handles);

    }

    workspaces[4].mon = nullptr;

    assert(free_workspace() == &workspaces[4]);

    assert(free_workspace() == nullptr);

    wl_list_init(&clients);

    workspace      = &workspaces[2];

    workspace->mon = nullptr;

    client = pool_take(&client_pool);

    assert(client);

    client->ws        = workspace;

    client->is_urgent = 1;

    wl_list_insert(&clients, &client->link);

    assert(

        (EXT_WORKSPACE_HANDLE_V1_STATE_ACTIVE | EXT_WORKSPACE_HANDLE_V1_STATE_URGENT)

    );

    wl_list_remove(&client->link);

    pool_release(&client_pool, client);

}

/* Verify state-file paths and client border-width policy. */