swm is configured in C and aims to remain small enough to understand, modify,

and extend. It supports native Wayland clients, X11 clients through Xwayland,

multiple outputs, global workspaces, server-side decorations, layer-shell

panels and launchers, session locking, idle inhibition, input methods, and

# REQUIREMENTS

Building swm requires:

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. The active window title is published atomically to

`$XDG_RUNTIME_DIR/swm-title`, which can be consumed by a custom bar module.

# TESTING AND DEVELOPMENT

Run the complete test suite with:

#include <wlr/types/wlr_data_device.h>

#include <wlr/types/wlr_drm.h>

#include <wlr/types/wlr_export_dmabuf_v1.h>

#include <wlr/types/wlr_ext_data_control_v1.h>

#include <wlr/types/wlr_ext_foreign_toplevel_list_v1.h>

#include <wlr/types/wlr_foreign_toplevel_management_v1.h>

#include <wlr/types/wlr_fractional_scale_v1.h>

#include <wlr/types/wlr_gamma_control_v1.h>

#include <wlr/types/wlr_idle_inhibit_v1.h>

#include <wlr/types/wlr_idle_notify_v1.h>

static void              focus_client(client_t *c, int lift);

static client_t         *focus_close(client_t *c);

static void              focus_main(const arg_t *arg);

static void              focus_urgent(const arg_t *arg);

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

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

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

static void              ftl_sync(client_t *c);

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

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

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

static void pointer_focus(

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

);

static void         print_status(void);

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);

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

static struct wlr_input_method_v2                       *input_method; /* at most one */

static struct wl_listener im_commit    = { .notify = input_method_commit_notify };

static struct wl_listener im_destroy   = { .notify = input_method_destroy_notify };

static struct wl_listener im_grab_kb   = { .notify = input_method_grab_keyboard };

static struct wl_listener im_new_popup = { .notify = input_method_new_popup };

static struct wlr_pointer_constraints_v1      *pointer_constraints;

static struct wlr_relative_pointer_manager_v1 *relative_pointer_mgr;

static struct wlr_pointer_constraint_v1       *active_constraint;

    wl_list_remove(&new_xdg_toplevel.link);

    wl_list_remove(&new_text_input.link);

    wl_list_remove(&new_xdg_decoration.link);

    wl_list_remove(&new_xdg_popup.link);

    wl_list_remove(&new_layer_surface.link);

    wl_list_remove(&output_mgr_apply.link);

    wl_list_remove(&output_mgr_test.link);

    wl_list_remove(&output_power_mgr_set_mode.link);

    wl_list_remove(&request_activate.link);

    wl_list_remove(&request_cursor.link);

    if (c->ws && c->ws->mon != selmon)

        view_workspace(c->ws, selmon);

    focus_client(c, 1);

}

/* Forward a taskbar's close request to the selected window. */

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

    client_t *c = wl_container_of(listener, c, ftl_close);

    client_send_close(c);

        &(struct wlr_ext_foreign_toplevel_handle_v1_state){

            .app_id = client_get_appid(c),

            .title  = client_get_title(c),

        }

    );

    ftl_sync(c);

    /* A managed window can receive keyboard focus only after it is visible. */

    if (c->ws && c->ws->mon)

        focus_client(c, 1);

    c->pending_map = 0;

/* Replace line-breaking characters before writing a status field. */

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

    swm_sanitize_field(dst, size, src, nullptr);

}

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

void print_status(void) {

    monitor_t  *m = nullptr;

    client_t   *c;

    FILE       *titlefile;

            m->ws ? 1u << m->ws->idx : 0,

            urg

        );

    }

    runtime = getenv("XDG_RUNTIME_DIR");

    if (runtime && selmon) {

        src = (c = focus_top(selmon)) ? client_get_title(c) : "";

        status_field(title, sizeof(title), src);

        snprintf(titlepath, sizeof(titlepath), "%s/swm-title", runtime);

    wl_global_create(dpy, &ext_workspace_manager_v1_interface, 1, nullptr, workspace_manager_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);

    /* Let virtual machines and remote desktops capture window-manager shortcuts. */

    kb_inhibit_mgr = wlr_keyboard_shortcuts_inhibit_v1_create(dpy);

    wl_signal_add(&kb_inhibit_mgr->events.new_inhibitor, &new_shortcuts_inhibitor_listener);