SRC   := swm.c util.c ext-workspace-v1-protocol.c swm-toplevel-v1-protocol.c \

	swm-workspace-v1-protocol.c

	swm-toplevel-v1-protocol.h \

swmctl: swmctl.o ext-foreign-toplevel-list-v1-protocol.o \

		swm-toplevel-v1-protocol.o swm-workspace-v1-protocol.o

swmctl.o: swmctl.c ext-foreign-toplevel-list-v1-client-protocol.h \

		swm-toplevel-v1-client-protocol.h swm-workspace-v1-client-protocol.h \

		Makefile config.mk

ext-foreign-toplevel-list-v1-client-protocol.h: \

		$(WL_PROTO)/staging/ext-foreign-toplevel-list/ext-foreign-toplevel-list-v1.xml

	@echo "hdr  $@"

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

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

		$(WL_PROTO)/staging/ext-foreign-toplevel-list/ext-foreign-toplevel-list-v1.xml

	@echo "src  $@"

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

swm-toplevel-v1-protocol.h: protocols/swm-toplevel-v1.xml

	@echo "hdr  $@"

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

swm-toplevel-v1-client-protocol.h: protocols/swm-toplevel-v1.xml

	@echo "hdr  $@"

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

swm-toplevel-v1-protocol.c: protocols/swm-toplevel-v1.xml

	@echo "src  $@"

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

	swm.h util.c util.h $(PROTO) ext-workspace-v1-protocol.c \

	swm-toplevel-v1-protocol.c swm-workspace-v1-protocol.c

		ext-workspace-v1-protocol.c swm-toplevel-v1-protocol.c \

		swm-workspace-v1-protocol.c $(LDLIBS) -o $@

		ext-workspace-v1-protocol.c swm-toplevel-v1-protocol.c \

		swm-workspace-v1-protocol.c $(LDLIBS) -o $@

$(TEST_BIN)/swmctl: swmctl.c ext-foreign-toplevel-list-v1-client-protocol.h \

		swm-toplevel-v1-client-protocol.h swm-workspace-v1-client-protocol.h \

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

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

<?xml version="1.0" encoding="UTF-8"?>

<protocol name="swm_toplevel_v1">

  <copyright>

    Copyright (C) 2026 swm contributors

    Permission to use, copy, modify, distribute, and sell this software and its

    documentation for any purpose is hereby granted without fee, provided that

    the above copyright notice and this permission notice appear in all copies.

    THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    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>

  <interface name="swm_toplevel_manager_v1" version="1">

    <description summary="activate swm toplevels">

      This interface activates mapped toplevels by the stable identifier from

      ext-foreign-toplevel-list-v1.

    </description>

    <enum name="error">

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

    </enum>

    <request name="activate">

      <description summary="show and focus a toplevel">

        Show the toplevel's workspace on the selected output and focus it.

      </description>

      <arg name="identifier" type="string" summary="ext-foreign-toplevel-list identifier"/>

    </request>

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

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

    </request>

  </interface>

</protocol>

#include "swm-toplevel-v1-protocol.h"

static void toplevel_control_bind(

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

);

/* Show and focus a toplevel selected by its ext-foreign-toplevel identifier. */

static void toplevel_control_activate(

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

) {

    client_t *c;

    wl_list_for_each(c, &clients, link) {

        if (!c->extftl || strcmp(c->extftl->identifier, identifier))

            continue;

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

            view_workspace(c->ws, selmon);

        focus_client(c, 1);

        return;

    }

    wl_resource_post_error(

        resource,

        SWM_TOPLEVEL_MANAGER_V1_ERROR_INVALID_IDENTIFIER,

        "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 = {

    .activate = toplevel_control_activate,

    .destroy  = toplevel_control_destroy,

};

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

) {

    struct wl_resource *resource =

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

    if (!resource) {

        wl_client_post_no_memory(client);

        return;

    }

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

}

    wl_global_create(dpy, &swm_toplevel_manager_v1_interface, 1, nullptr, toplevel_control_bind);

#include "ext-foreign-toplevel-list-v1-client-protocol.h"

#include "swm-toplevel-v1-client-protocol.h"

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

enum command_kind {

    COMMAND_WORKSPACE,

    COMMAND_WINDOW_LIST,

    COMMAND_WINDOW_ACTIVATE,

};

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

typedef struct {

    struct wl_list                         link;

    struct ext_foreign_toplevel_handle_v1 *handle;

    char                                  *title;

    char                                  *app_id;

    char                                   identifier[33];

    bool                                   closed;

} window_t;

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;

static enum command_kind                    requested_kind;

        "  swmctl window list\n"

        "  swmctl window activate IDENTIFIER\n"

/* Replace one cached toplevel string. */

static void replace_string(char **target, const char *value) {

    char *copy = strdup(value);

    if (!copy) {

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

        exit(EXIT_FAILURE);

    }

    free(*target);

    *target = copy;

}

/* Release a closed toplevel handle. */

static void window_closed(void *data, struct ext_foreign_toplevel_handle_v1 *handle) {

    window_t *window = data;

    ext_foreign_toplevel_handle_v1_destroy(handle);

    window->handle = nullptr;

    window->closed = true;

}

/* Accept a complete toplevel state update. */

static void window_done(void *data, struct ext_foreign_toplevel_handle_v1 *handle) {}

/* Cache a toplevel title. */

static void window_title(

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

) {

    window_t *window = data;

    replace_string(&window->title, title);

}

/* Cache a toplevel application ID. */

static void window_app_id(

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

) {

    window_t *window = data;

    replace_string(&window->app_id, app_id);

}

/* Cache a toplevel's stable identifier. */

static void window_identifier(

    void *data, struct ext_foreign_toplevel_handle_v1 *handle, const char *identifier

) {

    window_t *window = data;

    if (strlen(identifier) >= sizeof(window->identifier)) {

        fprintf(stderr, "swmctl: compositor sent an invalid toplevel identifier\n");

        exit(EXIT_FAILURE);

    }

    strcpy(window->identifier, identifier);

}

static const struct ext_foreign_toplevel_handle_v1_listener window_listener = {

    .closed     = window_closed,

    .done       = window_done,

    .title      = window_title,

    .app_id     = window_app_id,

    .identifier = window_identifier,

};

/* Cache a toplevel announced by ext-foreign-toplevel-list. */

static void window_announced(

    void                                  *data,

    struct ext_foreign_toplevel_list_v1   *list,

    struct ext_foreign_toplevel_handle_v1 *handle

) {

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

    if (!window) {

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

        exit(EXIT_FAILURE);

    }

    window->handle = handle;

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

    ext_foreign_toplevel_handle_v1_add_listener(handle, &window_listener, window);

}

/* Record that the compositor accepted the list's stop request. */

static void window_list_finished(void *data, struct ext_foreign_toplevel_list_v1 *list) {

    toplevel_list_finished = true;

}

static const struct ext_foreign_toplevel_list_v1_listener window_list_listener = {

    .toplevel = window_announced,

    .finished = window_list_finished,

};

/* Bind swm's workspace and toplevel control globals. */

    if (requested_kind == COMMAND_WORKSPACE &&

        !strcmp(interface, swm_workspace_manager_v1_interface.name)) {

        manager = wl_registry_bind(registry, name, &swm_workspace_manager_v1_interface, 1);

        swm_workspace_manager_v1_add_listener(manager, &manager_listener, nullptr);

    } else if (

        requested_kind == COMMAND_WINDOW_LIST &&

        !strcmp(interface, ext_foreign_toplevel_list_v1_interface.name)

    ) {

        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 (

        requested_kind == COMMAND_WINDOW_ACTIVATE &&

        !strcmp(interface, swm_toplevel_manager_v1_interface.name)

    ) {

        toplevel_control = wl_registry_bind(registry, name, &swm_toplevel_manager_v1_interface, 1);

    }

/* Write a field with line and column separators escaped. */

static void print_window_field(const char *value) {

    const unsigned char *p;

    for (p = (const unsigned char *)(value ? value : ""); *p; p++) {

        if (*p == '\\')

            fputs("\\\\", stdout);

        else if (*p == '\t')

            fputs("\\t", stdout);

        else if (*p == '\n')

            fputs("\\n", stdout);

        else if (*p == '\r')

            fputs("\\r", stdout);

        else

            putchar(*p);

    }

}

/* Print mapped toplevels as title, application ID, and identifier fields. */

static void print_windows(void) {

    window_t *window;

    wl_list_for_each(window, &windows, link) {

        if (window->closed || !window->identifier[0])

            continue;

        print_window_field(window->title);

        putchar('\t');

        print_window_field(window->app_id);

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

        if (window->handle)

            ext_foreign_toplevel_handle_v1_destroy(window->handle);

        wl_list_remove(&window->link);

        free(window->title);

        free(window->app_id);

        free(window);

    }

}

/* Stop the list, then release its child handles before the list object. */

static bool destroy_window_list(void) {

    if (!toplevel_list_finished) {

        ext_foreign_toplevel_list_v1_stop(toplevel_list);

        if (wl_display_roundtrip(display) < 0 || !toplevel_list_finished)

            return false;

    }

    destroy_windows();

    ext_foreign_toplevel_list_v1_destroy(toplevel_list);

    toplevel_list = nullptr;

    return wl_display_flush(display) >= 0;

}

/* Connect to swm and collect the requested initial state. */

static void connect_manager(enum command_kind kind) {

    wl_list_init(&windows);

    requested_kind = kind;

    registry       = wl_display_get_registry(display);

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

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

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

        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"

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

        );

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

        fprintf(

            stderr,

            kind == COMMAND_WORKSPACE ? "swmctl: failed to read workspace metadata\n"

                                      : "swmctl: failed to read toplevels\n"

        );

    const char *identifier = nullptr;

    bool        window_command;

    if (argc < 3)

    window_command = !strcmp(argv[1], "window");

    command        = argv[2];

    if (window_command) {

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

            if (argc != 3)

                usage();

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

            if (argc != 4)

                usage();

            identifier = argv[3];

        } else {

            usage();

        }

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

        usage();

    }

    subscribing = !window_command && !strcmp(command, "subscribe");

    if (window_command) {

        ;

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

    connect_manager(

        !window_command            ? COMMAND_WORKSPACE

        : !strcmp(command, "list") ? COMMAND_WINDOW_LIST

                                   : COMMAND_WINDOW_ACTIVATE

    );

    if (window_command) {

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

            print_windows();

        else

            swm_toplevel_manager_v1_activate(toplevel_control, identifier);

    } else if (subscribing) {

    if (!window_command && !strcmp(command, "list")) {

    } else if (!window_command) {

    if (requested_kind == COMMAND_WINDOW_LIST && !destroy_window_list()) {

        fprintf(stderr, "swmctl: failed to release toplevel list\n");

        return EXIT_FAILURE;

    }

    if (toplevel_control)

        swm_toplevel_manager_v1_destroy(toplevel_control);

    if (manager)

        swm_workspace_manager_v1_destroy(manager);

    def window_control() -> None:

        target = current_title()

        virtual_keyboard(3, 1)

        eventually("focus after moving switch target", lambda: current_title() != target)

        listed = run(BIN / "swmctl", "window", "list").splitlines()

        matches = [line for line in listed if line.split("\t", 1)[0] == target]

        if len(matches) != 1 or len(matches[0].split("\t")) != 3:

            raise Failure(f"unexpected toplevel list: {listed!r}")

        identifier = matches[0].rsplit("\t", 1)[1]

        duplicate = start_client(target, "5588ffdd")

        listed = run(BIN / "swmctl", "window", "list").splitlines()

        matches = [line for line in listed if line.split("\t", 1)[0] == target]

        if len(matches) != 2:

            raise Failure(f"duplicate title missing from toplevel list: {listed!r}")

        run(BIN / "swmctl", "window", "activate", identifier)

        wait_title(target)

        selected = run(BIN / "swmctl", "workspace", "get", 2, "selected")

        if selected != "true\n":

            raise Failure("identifier activation selected the duplicate window")

        terminate(duplicate)

        virtual_keyboard(2, 1)

        virtual_keyboard(2)

    test("window control", window_control)