From aaae66113d2d9133edee538ece882ea8087191c5 Mon Sep 17 00:00:00 2001 From: DreamMaoMao <2523610504@qq.com> Date: Sat, 16 Aug 2025 18:10:44 +0800 Subject: [PATCH 1/3] feat: wlr-ext-workspace support --- src/common/util.c | 4 + src/common/util.h | 2 + src/ext-protocol/all.h | 1 + src/ext-protocol/ext-workspace.h | 184 +++++++++++++++++++++++++++++++ src/mango.c | 31 +++++- 5 files changed, 218 insertions(+), 4 deletions(-) create mode 100644 src/ext-protocol/ext-workspace.h diff --git a/src/common/util.c b/src/common/util.c index ccc6e41..272340c 100644 --- a/src/common/util.c +++ b/src/common/util.c @@ -76,3 +76,7 @@ int regex_match(const char *pattern, const char *str) { pcre2_code_free(re); return ret >= 0; } + +void wl_list_append(struct wl_list *list, struct wl_list *object) { + wl_list_insert(list->prev, object); +} diff --git a/src/common/util.h b/src/common/util.h index 5807c2f..2ebef43 100644 --- a/src/common/util.h +++ b/src/common/util.h @@ -1,6 +1,8 @@ /* See LICENSE.dwm file for copyright and license details. */ +#include void die(const char *fmt, ...); void *ecalloc(size_t nmemb, size_t size); int fd_set_nonblock(int fd); int regex_match(const char *pattern_mb, const char *str_mb); +void wl_list_append(struct wl_list *list, struct wl_list *object); diff --git a/src/ext-protocol/all.h b/src/ext-protocol/all.h index c657e0d..0103248 100644 --- a/src/ext-protocol/all.h +++ b/src/ext-protocol/all.h @@ -1,3 +1,4 @@ #include "dwl-ipc.h" +#include "ext-workspace.h" #include "foreign-toplevel.h" #include "text-input.h" \ No newline at end of file diff --git a/src/ext-protocol/ext-workspace.h b/src/ext-protocol/ext-workspace.h new file mode 100644 index 0000000..201ce84 --- /dev/null +++ b/src/ext-protocol/ext-workspace.h @@ -0,0 +1,184 @@ +#include + +typedef struct Monitor Monitor; + +struct workspace { + struct wl_list link; // Link in global workspaces list + unsigned int tag; // Numeric identifier (1-9, 0=overview) + Monitor *m; // Associated monitor + struct wlr_ext_workspace_handle_v1 *ext_workspace; // Protocol object + /* Event listeners */ + struct wl_listener activate; + struct wl_listener deactivate; + struct wl_listener assign; + struct wl_listener remove; +}; + +struct wlr_ext_workspace_manager_v1 *ext_manager; +struct wl_list workspaces; + +void goto_workspace(struct workspace *target) { + unsigned int tag; + tag = 1 << (target->tag - 1); + if (target->tag == 0) { + toggleoverview(&(Arg){.i = -1}); + return; + } else { + view(&(Arg){.ui = tag}, true); + } +} + +static void handle_ext_workspace_activate(struct wl_listener *listener, + void *data) { + struct workspace *workspace = + wl_container_of(listener, workspace, activate); + goto_workspace(workspace); + wlr_log(WLR_INFO, "ext activating workspace %d", workspace->tag); +} + +static const char *get_name_from_tag(unsigned int tag) { + static const char *names[] = {"overview", "1", "2", "3", "4", + "5", "6", "7", "8", "9"}; + return (tag < sizeof(names) / sizeof(names[0])) ? names[tag] : NULL; +} + +void destroy_workspace(struct workspace *workspace) { + wl_list_remove(&workspace->activate.link); + wlr_ext_workspace_handle_v1_destroy(workspace->ext_workspace); + wl_list_remove(&workspace->link); + free(workspace); +} + +void cleanup_workspaces_by_monitor(Monitor *m) { + struct workspace *workspace, *tmp; + wl_list_for_each_safe(workspace, tmp, &workspaces, link) { + if (workspace->m == m) { + destroy_workspace(workspace); + } + } +} + +static void remove_workspace_by_tag(unsigned int tag, Monitor *m) { + struct workspace *workspace, *tmp; + wl_list_for_each_safe(workspace, tmp, &workspaces, link) { + if (workspace->tag == tag && workspace->m == m) { + destroy_workspace(workspace); + return; + } + } +} + +static void add_workspace_by_tag(int tag, Monitor *m) { + const char *name = get_name_from_tag(tag); + + struct workspace *workspace = ecalloc(1, sizeof(*workspace)); + wl_list_append(&workspaces, &workspace->link); + + workspace->tag = tag; + workspace->m = m; + workspace->ext_workspace = wlr_ext_workspace_handle_v1_create( + ext_manager, name, WLR_EXT_WORKSPACE_HANDLE_V1_CAP_ACTIVATE); + wlr_ext_workspace_handle_v1_set_group(workspace->ext_workspace, + m->ext_group); + wlr_ext_workspace_handle_v1_set_name(workspace->ext_workspace, name); + workspace->activate.notify = handle_ext_workspace_activate; + wl_signal_add(&workspace->ext_workspace->events.activate, + &workspace->activate); +} + +unsigned int get_tag_status(unsigned int tag) { + Client *c; + unsigned int status = 0; + wl_list_for_each(c, &clients, link) { + if (c->tags & 1 << (tag - 1) & TAGMASK) { + if (c->isurgent) { + status = 2; + break; + } + status = 1; + } + } + return status; +} + +unsigned int get_tags_first_tag_num(unsigned int source_tags) { + unsigned int i, tag; + tag = 0; + + if (!source_tags) { + return selmon->pertag->curtag; + } + + for (i = 0; !(tag & 1) && source_tags != 0 && i < LENGTH(tags); i++) { + tag = source_tags >> i; + } + + if (i == 1) { + return 1; + } else if (i > 9) { + return 9; + } else { + return i; + } +} + +void dwl_ext_workspace_printstatus(Monitor *m) { + unsigned int current_tag; + struct workspace *w; + unsigned int tag_status = 0; + bool is_active = false; + + current_tag = get_tags_first_tag_num(m->tagset[m->seltags]); + + wl_list_for_each(w, &workspaces, link) { + if (w && w->m == m) { + is_active = (w->tag == current_tag) || m->isoverview; + tag_status = get_tag_status(w->tag); + if (is_active) { + wlr_ext_workspace_handle_v1_set_urgent(w->ext_workspace, false); + wlr_ext_workspace_handle_v1_set_hidden(w->ext_workspace, false); + } else if (tag_status == 2) { + wlr_ext_workspace_handle_v1_set_hidden(w->ext_workspace, false); + wlr_ext_workspace_handle_v1_set_urgent(w->ext_workspace, true); + } else if (tag_status == 1) { + wlr_ext_workspace_handle_v1_set_urgent(w->ext_workspace, false); + wlr_ext_workspace_handle_v1_set_hidden(w->ext_workspace, false); + } else { + wlr_ext_workspace_handle_v1_set_urgent(w->ext_workspace, false); + wlr_ext_workspace_handle_v1_set_hidden(w->ext_workspace, true); + } + + if (m->tagset[m->seltags] & (1 << (w->tag - 1)) & TAGMASK) { + wlr_ext_workspace_handle_v1_set_hidden(w->ext_workspace, false); + wlr_ext_workspace_handle_v1_set_active(w->ext_workspace, true); + } else { + wlr_ext_workspace_handle_v1_set_active(w->ext_workspace, false); + } + } + } +} + +void refresh_monitors_workspaces_status(Monitor *m) { + int i; + + if (m->isoverview) { + for (i = 1; i <= LENGTH(tags); i++) { + remove_workspace_by_tag(i, m); + } + add_workspace_by_tag(0, m); + } else { + remove_workspace_by_tag(0, m); + for (i = 1; i <= LENGTH(tags); i++) { + add_workspace_by_tag(i, m); + } + } + + dwl_ext_workspace_printstatus(m); +} + +void workspaces_init() { + /* Create the global workspace manager with activation capability */ + ext_manager = wlr_ext_workspace_manager_v1_create(dpy, 1); + /* Initialize the global workspaces list */ + wl_list_init(&workspaces); +} \ No newline at end of file diff --git a/src/mango.c b/src/mango.c index 3700441..8088c3f 100644 --- a/src/mango.c +++ b/src/mango.c @@ -423,6 +423,7 @@ struct Monitor { unsigned int visible_tiling_clients; struct wlr_scene_optimized_blur *blur; char last_surface_ws_name[256]; + struct wlr_ext_workspace_group_handle_v1 *ext_group; }; typedef struct { @@ -645,6 +646,7 @@ static bool check_hit_no_border(Client *c); static void reset_keyboard_layout(void); static void client_update_oldmonname_record(Client *c, Monitor *m); static void pending_kill_client(Client *c); +static unsigned int get_tags_first_tag_num(unsigned int source_tags); static void set_layer_open_animaiton(LayerSurface *l, struct wlr_box geo); static void init_fadeout_layers(LayerSurface *l); static void layer_actual_size(LayerSurface *l, unsigned int *width, @@ -1984,6 +1986,11 @@ void cleanupmon(struct wl_listener *listener, void *data) { wlr_layer_surface_v1_destroy(l->layer_surface); } + // clean ext-workspaces grouplab + wlr_ext_workspace_group_handle_v1_output_leave(m->ext_group, m->wlr_output); + wlr_ext_workspace_group_handle_v1_destroy(m->ext_group); + cleanup_workspaces_by_monitor(m); + wl_list_remove(&m->destroy.link); wl_list_remove(&m->frame.link); wl_list_remove(&m->link); @@ -2582,8 +2589,6 @@ void createmon(struct wl_listener *listener, void *data) { } } - printstatus(); - /* The xdg-protocol specifies: * * If the fullscreened surface is not opaque, the compositor must make @@ -2612,6 +2617,15 @@ void createmon(struct wl_listener *listener, void *data) { wlr_scene_optimized_blur_set_size(m->blur, m->m.width, m->m.height); // wlr_scene_node_set_enabled(&m->blur->node, 1); } + m->ext_group = wlr_ext_workspace_group_handle_v1_create( + ext_manager, WLR_EXT_WORKSPACE_HANDLE_V1_CAP_ACTIVATE); + wlr_ext_workspace_group_handle_v1_output_enter(m->ext_group, m->wlr_output); + + for (i = 1; i <= LENGTH(tags); i++) { + add_workspace_by_tag(i, m); + } + + printstatus(); } void // fix for 0.5 @@ -3773,7 +3787,11 @@ printstatus(void) { if (!m->wlr_output->enabled) { continue; } - dwl_ipc_output_printstatus(m); // 更新waybar上tag的状态 这里很关键 + // Update workspace active states + dwl_ext_workspace_printstatus(m); + + // Update IPC output status + dwl_ipc_output_printstatus(m); } } @@ -4662,6 +4680,9 @@ void setup(void) { wlr_xdg_foreign_registry_create(dpy); wlr_xdg_foreign_v1_create(dpy, foreign_registry); wlr_xdg_foreign_v2_create(dpy, foreign_registry); + + // ext-workspace协议 + workspaces_init(); #ifdef XWAYLAND /* * Initialise the XWayland X server. @@ -4808,7 +4829,6 @@ int hidecursor(void *data) { // 显示所有tag 或 跳转到聚焦窗口的tag void toggleoverview(const Arg *arg) { - Client *c; if (selmon->isoverview && ov_tab_mode && arg->i != -1 && selmon->sel) { @@ -4839,6 +4859,7 @@ void toggleoverview(const Arg *arg) { } else if (!selmon->isoverview && !selmon->sel) { target = (1 << (selmon->pertag->prevtag - 1)); view(&(Arg){.ui = target}, false); + refresh_monitors_workspaces_status(selmon); return; } @@ -4864,6 +4885,8 @@ void toggleoverview(const Arg *arg) { if (ov_tab_mode && selmon->isoverview && selmon->sel) { focusstack(&(Arg){.i = 1}); } + + refresh_monitors_workspaces_status(selmon); } void unlocksession(struct wl_listener *listener, void *data) { From d7fdaa42a3f745b569b4be9ecbcf2f1e9e1fe97a Mon Sep 17 00:00:00 2001 From: DreamMaoMao <2523610504@qq.com> Date: Tue, 26 Aug 2025 15:59:35 +0800 Subject: [PATCH 2/3] feat:add ext-workspace protocol file for temp --- meson.build | 1 + protocols/meson.build | 1 + src/ext-protocol/ext-workspace.h | 2 +- src/ext-protocol/wlr_ext_workspace_v1.c | 930 ++++++++++++++++++++++++ src/ext-protocol/wlr_ext_workspace_v1.h | 109 +++ 5 files changed, 1042 insertions(+), 1 deletion(-) create mode 100644 src/ext-protocol/wlr_ext_workspace_v1.c create mode 100644 src/ext-protocol/wlr_ext_workspace_v1.h diff --git a/meson.build b/meson.build index c766012..80d6cf2 100644 --- a/meson.build +++ b/meson.build @@ -86,6 +86,7 @@ endif executable('mango', 'src/mango.c', 'src/common/util.c', + 'src/ext-protocol/wlr_ext_workspace_v1.c', wayland_sources, dependencies : [ libm, diff --git a/protocols/meson.build b/protocols/meson.build index 6079908..1069157 100644 --- a/protocols/meson.build +++ b/protocols/meson.build @@ -18,6 +18,7 @@ wayland_xmls = [ wl_protocol_dir + '/staging/ext-image-copy-capture/ext-image-copy-capture-v1.xml', wl_protocol_dir + '/staging/ext-image-capture-source/ext-image-capture-source-v1.xml', wl_protocol_dir + '/staging/ext-foreign-toplevel-list/ext-foreign-toplevel-list-v1.xml', + wl_protocol_dir + '/staging/ext-workspace/ext-workspace-v1.xml', 'wlr-foreign-toplevel-management-unstable-v1.xml', 'dwl-ipc-unstable-v2.xml', 'wlr-layer-shell-unstable-v1.xml', diff --git a/src/ext-protocol/ext-workspace.h b/src/ext-protocol/ext-workspace.h index 201ce84..78cc35a 100644 --- a/src/ext-protocol/ext-workspace.h +++ b/src/ext-protocol/ext-workspace.h @@ -1,4 +1,4 @@ -#include +#include "wlr_ext_workspace_v1.h" typedef struct Monitor Monitor; diff --git a/src/ext-protocol/wlr_ext_workspace_v1.c b/src/ext-protocol/wlr_ext_workspace_v1.c new file mode 100644 index 0000000..d2c7c16 --- /dev/null +++ b/src/ext-protocol/wlr_ext_workspace_v1.c @@ -0,0 +1,930 @@ +#include +#include +#include +#include "wlr_ext_workspace_v1.h" +#include +#include "ext-workspace-v1-protocol.h" + +#define EXT_WORKSPACE_V1_VERSION 1 + +enum wlr_ext_workspace_v1_request_type { + WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE, + WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE, + WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE, + WLR_EXT_WORKSPACE_V1_REQUEST_ASSIGN, + WLR_EXT_WORKSPACE_V1_REQUEST_REMOVE, +}; + +struct wlr_ext_workspace_v1_request { + enum wlr_ext_workspace_v1_request_type type; + + // CREATE_WORKSPACE + char *name; + // CREATE_WORKSPACE / ASSIGN + struct wlr_ext_workspace_group_handle_v1 *group; + // ACTIVATE / DEACTIVATE / ASSIGN / REMOVE + struct wlr_ext_workspace_handle_v1 *workspace; + + struct wl_list link; // wlr_ext_workspace_manager_client_v1.requests +}; + +struct wlr_ext_workspace_v1_group_output { + struct wlr_output *output; + struct wlr_ext_workspace_group_handle_v1 *group; + struct wl_listener output_bind; + struct wl_listener output_destroy; + struct wl_list link; +}; + +// These structs wrap wl_resource of each interface to access the request queue +// (wlr_ext_workspace_manager_client_v1.requests) assigned per manager resource + +struct wlr_ext_workspace_manager_client_v1 { + struct wl_resource *resource; + struct wlr_ext_workspace_manager_v1 *manager; + struct wl_list requests; // wlr_ext_workspace_v1_request.link + struct wl_list link; // wlr_ext_workspace_manager_v1.clients +}; + +struct wlr_ext_workspace_group_client_v1 { + struct wl_resource *resource; + struct wlr_ext_workspace_group_handle_v1 *group; + struct wlr_ext_workspace_manager_client_v1 *manager; + struct wl_list link; // wlr_ext_workspace_group_v1.clients +}; + +struct wlr_ext_workspace_client_v1 { + struct wl_resource *resource; + struct wlr_ext_workspace_handle_v1 *workspace; + struct wlr_ext_workspace_manager_client_v1 *manager; + struct wl_list link; // wlr_ext_workspace_v1.clients +}; + +static const struct ext_workspace_group_handle_v1_interface group_impl; + +static struct wlr_ext_workspace_group_client_v1 *group_client_from_resource( + struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, + &ext_workspace_group_handle_v1_interface, &group_impl)); + return wl_resource_get_user_data(resource); +} + +static const struct ext_workspace_handle_v1_interface workspace_impl; + +static struct wlr_ext_workspace_client_v1 *workspace_client_from_resource( + struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, + &ext_workspace_handle_v1_interface, &workspace_impl)); + return wl_resource_get_user_data(resource); +} + +static const struct ext_workspace_manager_v1_interface manager_impl; + +static struct wlr_ext_workspace_manager_client_v1 *manager_client_from_resource( + struct wl_resource *resource) { + assert(wl_resource_instance_of(resource, + &ext_workspace_manager_v1_interface, &manager_impl)); + return wl_resource_get_user_data(resource); +} + +static void workspace_handle_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static void workspace_handle_activate(struct wl_client *client, + struct wl_resource *workspace_resource) { + struct wlr_ext_workspace_client_v1 *workspace = + workspace_client_from_resource(workspace_resource); + if (!workspace) { + return; + } + + struct wlr_ext_workspace_v1_request *req = calloc(1, sizeof(*req)); + if (!req) { + wl_resource_post_no_memory(workspace_resource); + return; + } + req->type = WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE; + req->workspace = workspace->workspace; + wl_list_insert(workspace->manager->requests.prev, &req->link); +} + +static void workspace_handle_deactivate(struct wl_client *client, + struct wl_resource *workspace_resource) { + struct wlr_ext_workspace_client_v1 *workspace = + workspace_client_from_resource(workspace_resource); + if (!workspace) { + return; + } + + struct wlr_ext_workspace_v1_request *req = calloc(1, sizeof(*req)); + if (!req) { + wl_resource_post_no_memory(workspace_resource); + return; + } + req->type = WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE; + req->workspace = workspace->workspace; + wl_list_insert(workspace->manager->requests.prev, &req->link); +} + +static void workspace_handle_assign(struct wl_client *client, + struct wl_resource *workspace_resource, + struct wl_resource *group_resource) { + struct wlr_ext_workspace_client_v1 *workspace = + workspace_client_from_resource(workspace_resource); + struct wlr_ext_workspace_group_client_v1 *group = + group_client_from_resource(group_resource); + if (!workspace || !group) { + return; + } + + struct wlr_ext_workspace_v1_request *req = calloc(1, sizeof(*req)); + if (!req) { + wl_resource_post_no_memory(workspace_resource); + return; + } + req->type = WLR_EXT_WORKSPACE_V1_REQUEST_ASSIGN; + req->group = group->group; + req->workspace = workspace->workspace; + wl_list_insert(workspace->manager->requests.prev, &req->link); +} + +static void workspace_handle_remove(struct wl_client *client, + struct wl_resource *workspace_resource) { + struct wlr_ext_workspace_client_v1 *workspace = + workspace_client_from_resource(workspace_resource); + if (!workspace) { + return; + } + + struct wlr_ext_workspace_v1_request *req = calloc(1, sizeof(*req)); + if (!req) { + wl_resource_post_no_memory(workspace_resource); + return; + } + req->type = WLR_EXT_WORKSPACE_V1_REQUEST_REMOVE; + req->workspace = workspace->workspace; + wl_list_insert(workspace->manager->requests.prev, &req->link); +} + +static const struct ext_workspace_handle_v1_interface workspace_impl = { + .destroy = workspace_handle_destroy, + .activate = workspace_handle_activate, + .deactivate = workspace_handle_deactivate, + .assign = workspace_handle_assign, + .remove = workspace_handle_remove, +}; + +static void group_handle_create_workspace(struct wl_client *client, + struct wl_resource *group_resource, const char *name) { + struct wlr_ext_workspace_group_client_v1 *group = + group_client_from_resource(group_resource); + if (!group) { + return; + } + + struct wlr_ext_workspace_v1_request *req = calloc(1, sizeof(*req)); + if (!req) { + wl_resource_post_no_memory(group_resource); + return; + } + req->type = WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE; + req->group = group->group; + wl_list_insert(group->manager->requests.prev, &req->link); +} + +static void group_handle_destroy(struct wl_client *client, + struct wl_resource *resource) { + wl_resource_destroy(resource); +} + +static const struct ext_workspace_group_handle_v1_interface group_impl = { + .create_workspace = group_handle_create_workspace, + .destroy = group_handle_destroy, +}; + +static void destroy_workspace_client( + struct wlr_ext_workspace_client_v1 *workspace_client) { + wl_list_remove(&workspace_client->link); + wl_resource_set_user_data(workspace_client->resource, NULL); + free(workspace_client); +} + +static void workspace_resource_destroy(struct wl_resource *resource) { + struct wlr_ext_workspace_client_v1 *workspace_client = + workspace_client_from_resource(resource); + if (workspace_client) { + destroy_workspace_client(workspace_client); + } +} + +static struct wlr_ext_workspace_client_v1 *create_workspace_client( + struct wlr_ext_workspace_handle_v1 *workspace, + struct wlr_ext_workspace_manager_client_v1 *manager_client) { + struct wlr_ext_workspace_client_v1 *workspace_client = + calloc(1, sizeof(*workspace_client)); + if (!workspace_client) { + return NULL; + } + + struct wl_client *client = wl_resource_get_client(manager_client->resource); + workspace_client->resource = wl_resource_create(client, + &ext_workspace_handle_v1_interface, + wl_resource_get_version(manager_client->resource), 0); + if (!workspace_client->resource) { + free(workspace_client); + return NULL; + } + wl_resource_set_implementation(workspace_client->resource, + &workspace_impl, workspace_client, workspace_resource_destroy); + + workspace_client->workspace = workspace; + workspace_client->manager = manager_client; + wl_list_insert(&workspace->clients, &workspace_client->link); + + return workspace_client; +} + +static void destroy_group_client(struct wlr_ext_workspace_group_client_v1 *group_client) { + wl_list_remove(&group_client->link); + wl_resource_set_user_data(group_client->resource, NULL); + free(group_client); +} + +static void group_handle_resource_destroy(struct wl_resource *resource) { + struct wlr_ext_workspace_group_client_v1 *group_client = + group_client_from_resource(resource); + if (group_client) { + destroy_group_client(group_client); + } +} + +static struct wlr_ext_workspace_group_client_v1 *create_group_client( + struct wlr_ext_workspace_group_handle_v1 *group, + struct wlr_ext_workspace_manager_client_v1 *manager_client) { + struct wlr_ext_workspace_group_client_v1 *group_client = + calloc(1, sizeof(*group_client)); + if (!group_client) { + return NULL; + } + + struct wl_client *client = wl_resource_get_client(manager_client->resource); + uint32_t version = wl_resource_get_version(manager_client->resource); + group_client->resource = wl_resource_create(client, + &ext_workspace_group_handle_v1_interface, version, 0); + if (group_client->resource == NULL) { + free(group_client); + return NULL; + } + wl_resource_set_implementation(group_client->resource, &group_impl, + group_client, group_handle_resource_destroy); + + group_client->group = group; + group_client->manager = manager_client; + wl_list_insert(&group->clients, &group_client->link); + + return group_client; +} + +static void destroy_request(struct wlr_ext_workspace_v1_request *req) { + wl_list_remove(&req->link); + free(req->name); + free(req); +} + +static void manager_handle_commit(struct wl_client *client, struct wl_resource *resource) { + struct wlr_ext_workspace_manager_client_v1 *manager = + manager_client_from_resource(resource); + if (!manager) { + return; + } + + struct wlr_ext_workspace_v1_request *req, *tmp; + wl_list_for_each_safe(req, tmp, &manager->requests, link) { + switch (req->type) { + case WLR_EXT_WORKSPACE_V1_REQUEST_CREATE_WORKSPACE: + wl_signal_emit_mutable( + &req->group->events.create_workspace, req->name); + break; + case WLR_EXT_WORKSPACE_V1_REQUEST_ACTIVATE: + wl_signal_emit_mutable( + &req->workspace->events.activate, NULL); + break; + case WLR_EXT_WORKSPACE_V1_REQUEST_DEACTIVATE: + wl_signal_emit_mutable( + &req->workspace->events.deactivate, NULL); + break; + case WLR_EXT_WORKSPACE_V1_REQUEST_ASSIGN: + wl_signal_emit_mutable( + &req->workspace->events.assign, &req->group); + break; + case WLR_EXT_WORKSPACE_V1_REQUEST_REMOVE: + wl_signal_emit_mutable( + &req->workspace->events.remove, NULL); + break; + default: + abort(); + } + destroy_request(req); + } +} + +static void handle_idle(void *data) { + struct wlr_ext_workspace_manager_v1 *manager = data; + + struct wlr_ext_workspace_manager_client_v1 *manager_client; + wl_list_for_each(manager_client, &manager->clients, link) { + ext_workspace_manager_v1_send_done(manager_client->resource); + } + manager->idle_source = NULL; +} + +static void manager_schedule_done(struct wlr_ext_workspace_manager_v1 *manager) { + if (!manager->idle_source) { + manager->idle_source = wl_event_loop_add_idle(manager->event_loop, + handle_idle, manager); + } +} + +static void workspace_send_details(struct wlr_ext_workspace_client_v1 *workspace_client) { + struct wlr_ext_workspace_handle_v1 *workspace = workspace_client->workspace; + struct wl_resource *resource = workspace_client->resource; + + ext_workspace_handle_v1_send_capabilities(resource, workspace->caps); + if (workspace->coordinates.size > 0) { + ext_workspace_handle_v1_send_coordinates(resource, &workspace->coordinates); + } + if (workspace->name) { + ext_workspace_handle_v1_send_name(resource, workspace->name); + } + if (workspace->id) { + ext_workspace_handle_v1_send_id(resource, workspace->id); + } + ext_workspace_handle_v1_send_state(resource, workspace->state); + manager_schedule_done(workspace->manager); +} + +static void manager_handle_stop(struct wl_client *client, struct wl_resource *resource) { + ext_workspace_manager_v1_send_finished(resource); + wl_resource_destroy(resource); +} + +static const struct ext_workspace_manager_v1_interface manager_impl = { + .commit = manager_handle_commit, + .stop = manager_handle_stop, +}; + +static void destroy_manager_client(struct wlr_ext_workspace_manager_client_v1 *manager_client) { + struct wlr_ext_workspace_v1_request *req, *tmp; + wl_list_for_each_safe(req, tmp, &manager_client->requests, link) { + destroy_request(req); + } + wl_list_remove(&manager_client->link); + wl_resource_set_user_data(manager_client->resource, NULL); + free(manager_client); +} + +static void manager_resource_destroy(struct wl_resource *resource) { + struct wlr_ext_workspace_manager_client_v1 *manager_client = + manager_client_from_resource(resource); + if (manager_client) { + destroy_manager_client(manager_client); + } +} + +static void group_send_details(struct wlr_ext_workspace_group_client_v1 *group_client) { + struct wlr_ext_workspace_group_handle_v1 *group = group_client->group; + struct wl_resource *resource = group_client->resource; + struct wl_client *client = wl_resource_get_client(resource); + + ext_workspace_group_handle_v1_send_capabilities(resource, group->caps); + + struct wlr_ext_workspace_v1_group_output *group_output; + wl_list_for_each(group_output, &group->outputs, link) { + struct wl_resource *output_resource; + wl_resource_for_each(output_resource, &group_output->output->resources) { + if (wl_resource_get_client(output_resource) == client) { + ext_workspace_group_handle_v1_send_output_enter( + resource, output_resource); + } + } + } + + manager_schedule_done(group->manager); +} + +static void manager_bind(struct wl_client *client, void *data, + uint32_t version, uint32_t id) { + struct wlr_ext_workspace_manager_v1 *manager = data; + + struct wlr_ext_workspace_manager_client_v1 *manager_client = + calloc(1, sizeof(*manager_client)); + if (!manager_client) { + wl_client_post_no_memory(client); + return; + } + + manager_client->manager = manager; + wl_list_init(&manager_client->requests); + wl_list_insert(&manager->clients, &manager_client->link); + + manager_client->resource = wl_resource_create(client, + &ext_workspace_manager_v1_interface, version, id); + if (!manager_client->resource) { + free(manager_client); + wl_client_post_no_memory(client); + return; + } + wl_resource_set_implementation(manager_client->resource, &manager_impl, + manager_client, manager_resource_destroy); + + struct wlr_ext_workspace_group_handle_v1 *group; + wl_list_for_each(group, &manager->groups, link) { + struct wlr_ext_workspace_group_client_v1 *group_client = + create_group_client(group, manager_client); + if (!group_client) { + wl_resource_post_no_memory(manager_client->resource); + continue; + } + ext_workspace_manager_v1_send_workspace_group( + manager_client->resource, group_client->resource); + group_send_details(group_client); + } + + struct wlr_ext_workspace_handle_v1 *workspace; + wl_list_for_each(workspace, &manager->workspaces, link) { + struct wlr_ext_workspace_client_v1 *workspace_client = + create_workspace_client(workspace, manager_client); + if (!workspace) { + wl_client_post_no_memory(client); + continue; + } + ext_workspace_manager_v1_send_workspace( + manager_client->resource, workspace_client->resource); + workspace_send_details(workspace_client); + + if (!workspace->group) { + continue; + } + struct wlr_ext_workspace_group_client_v1 *group_client; + wl_list_for_each(group_client, &workspace->group->clients, link) { + if (group_client->manager == manager_client) { + ext_workspace_group_handle_v1_send_workspace_enter( + group_client->resource, workspace_client->resource); + } + } + } + + manager_schedule_done(manager); +} + +static void manager_handle_display_destroy(struct wl_listener *listener, void *data) { + struct wlr_ext_workspace_manager_v1 *manager = + wl_container_of(listener, manager, display_destroy); + + wl_signal_emit_mutable(&manager->events.destroy, NULL); + assert(wl_list_empty(&manager->events.destroy.listener_list)); + + struct wlr_ext_workspace_group_handle_v1 *group, *tmp; + wl_list_for_each_safe(group, tmp, &manager->groups, link) { + wlr_ext_workspace_group_handle_v1_destroy(group); + } + + struct wlr_ext_workspace_handle_v1 *workspace, *tmp2; + wl_list_for_each_safe(workspace, tmp2, &manager->workspaces, link) { + wlr_ext_workspace_handle_v1_destroy(workspace); + } + + struct wlr_ext_workspace_manager_client_v1 *manager_client, *tmp3; + wl_list_for_each_safe(manager_client, tmp3, &manager->clients, link) { + destroy_manager_client(manager_client); + } + + if (manager->idle_source) { + wl_event_source_remove(manager->idle_source); + } + + wl_list_remove(&manager->display_destroy.link); + wl_global_destroy(manager->global); + free(manager); +} + +struct wlr_ext_workspace_manager_v1 *wlr_ext_workspace_manager_v1_create( + struct wl_display *display, uint32_t version) { + assert(version <= EXT_WORKSPACE_V1_VERSION); + + struct wlr_ext_workspace_manager_v1 *manager = calloc(1, sizeof(*manager)); + if (!manager) { + return NULL; + } + + manager->global = wl_global_create(display, + &ext_workspace_manager_v1_interface, + version, manager, manager_bind); + if (!manager->global) { + free(manager); + return NULL; + } + + manager->event_loop = wl_display_get_event_loop(display); + + manager->display_destroy.notify = manager_handle_display_destroy; + wl_display_add_destroy_listener(display, &manager->display_destroy); + + wl_list_init(&manager->groups); + wl_list_init(&manager->workspaces); + wl_list_init(&manager->clients); + wl_signal_init(&manager->events.destroy); + + return manager; +} + +struct wlr_ext_workspace_group_handle_v1 *wlr_ext_workspace_group_handle_v1_create( + struct wlr_ext_workspace_manager_v1 *manager, uint32_t caps) { + struct wlr_ext_workspace_group_handle_v1 *group = calloc(1, sizeof(*group)); + if (!group) { + return NULL; + } + + group->manager = manager; + group->caps = caps; + + wl_list_init(&group->outputs); + wl_list_init(&group->clients); + wl_signal_init(&group->events.create_workspace); + wl_signal_init(&group->events.destroy); + + wl_list_insert(manager->groups.prev, &group->link); + + struct wlr_ext_workspace_manager_client_v1 *manager_client; + wl_list_for_each(manager_client, &manager->clients, link) { + struct wlr_ext_workspace_group_client_v1 *group_client = + create_group_client(group, manager_client); + if (!group_client) { + continue; + } + ext_workspace_manager_v1_send_workspace_group( + manager_client->resource, group_client->resource); + group_send_details(group_client); + } + + manager_schedule_done(manager); + + return group; +} + +static void workspace_send_group(struct wlr_ext_workspace_handle_v1 *workspace, + struct wlr_ext_workspace_group_handle_v1 *group, bool enter) { + + struct wlr_ext_workspace_client_v1 *workspace_client; + wl_list_for_each(workspace_client, &workspace->clients, link) { + struct wlr_ext_workspace_group_client_v1 *group_client; + wl_list_for_each(group_client, &group->clients, link) { + if (group_client->manager != workspace_client->manager) { + continue; + } + if (enter) { + ext_workspace_group_handle_v1_send_workspace_enter( + group_client->resource, workspace_client->resource); + } else { + ext_workspace_group_handle_v1_send_workspace_leave( + group_client->resource, workspace_client->resource); + } + } + } + + manager_schedule_done(workspace->manager); +} + +static void destroy_group_output(struct wlr_ext_workspace_v1_group_output *group_output) { + wl_list_remove(&group_output->output_bind.link); + wl_list_remove(&group_output->output_destroy.link); + wl_list_remove(&group_output->link); + free(group_output); +} + +static void group_send_output(struct wlr_ext_workspace_group_handle_v1 *group, + struct wlr_output *output, bool enter) { + + struct wlr_ext_workspace_group_client_v1 *group_client; + wl_list_for_each(group_client, &group->clients, link) { + struct wl_client *client = + wl_resource_get_client(group_client->resource); + + struct wl_resource *output_resource; + wl_resource_for_each(output_resource, &output->resources) { + if (wl_resource_get_client(output_resource) != client) { + continue; + } + if (enter) { + ext_workspace_group_handle_v1_send_output_enter( + group_client->resource, output_resource); + } else { + ext_workspace_group_handle_v1_send_output_leave( + group_client->resource, output_resource); + } + } + } + + manager_schedule_done(group->manager); +} + +void wlr_ext_workspace_group_handle_v1_destroy( + struct wlr_ext_workspace_group_handle_v1 *group) { + wl_signal_emit_mutable(&group->events.destroy, NULL); + + assert(wl_list_empty(&group->events.create_workspace.listener_list)); + assert(wl_list_empty(&group->events.destroy.listener_list)); + + struct wlr_ext_workspace_handle_v1 *workspace; + wl_list_for_each(workspace, &group->manager->workspaces, link) { + if (workspace->group == group) { + workspace_send_group(workspace, group, false); + workspace->group = NULL; + } + } + + struct wlr_ext_workspace_group_client_v1 *group_client, *tmp; + wl_list_for_each_safe(group_client, tmp, &group->clients, link) { + ext_workspace_group_handle_v1_send_removed(group_client->resource); + destroy_group_client(group_client); + } + + struct wlr_ext_workspace_manager_client_v1 *manager_client; + wl_list_for_each(manager_client, &group->manager->clients, link) { + struct wlr_ext_workspace_v1_request *req, *tmp2; + wl_list_for_each_safe(req, tmp2, &manager_client->requests, link) { + if (req->group == group) { + destroy_request(req); + } + } + } + + struct wlr_ext_workspace_v1_group_output *group_output, *tmp3; + wl_list_for_each_safe(group_output, tmp3, &group->outputs, link) { + group_send_output(group, group_output->output, false); + destroy_group_output(group_output); + } + + manager_schedule_done(group->manager); + + wl_list_remove(&group->link); + free(group); +} + +static void handle_output_bind(struct wl_listener *listener, void *data) { + struct wlr_ext_workspace_v1_group_output *group_output = + wl_container_of(listener, group_output, output_bind); + struct wlr_output_event_bind *event = data; + struct wl_client *client = wl_resource_get_client(event->resource); + + struct wlr_ext_workspace_group_client_v1 *group_client; + wl_list_for_each(group_client, &group_output->group->clients, link) { + if (wl_resource_get_client(group_client->resource) == client) { + ext_workspace_group_handle_v1_send_output_enter( + group_client->resource, event->resource); + } + } + + manager_schedule_done(group_output->group->manager); +} + +static void handle_output_destroy(struct wl_listener *listener, void *data) { + struct wlr_ext_workspace_v1_group_output *group_output = + wl_container_of(listener, group_output, output_destroy); + group_send_output(group_output->group, group_output->output, false); + destroy_group_output(group_output); +} + +static struct wlr_ext_workspace_v1_group_output *get_group_output( + struct wlr_ext_workspace_group_handle_v1 *group, + struct wlr_output *output) { + struct wlr_ext_workspace_v1_group_output *group_output; + wl_list_for_each(group_output, &group->outputs, link) { + if (group_output->output == output) { + return group_output; + } + } + return NULL; +} + +void wlr_ext_workspace_group_handle_v1_output_enter( + struct wlr_ext_workspace_group_handle_v1 *group, + struct wlr_output *output) { + if (get_group_output(group, output)) { + return; + } + struct wlr_ext_workspace_v1_group_output *group_output = + calloc(1, sizeof(*group_output)); + if (!group_output) { + return; + } + group_output->output = output; + group_output->group = group; + wl_list_insert(&group->outputs, &group_output->link); + + group_output->output_bind.notify = handle_output_bind; + wl_signal_add(&output->events.bind, &group_output->output_bind); + group_output->output_destroy.notify = handle_output_destroy; + wl_signal_add(&output->events.destroy, &group_output->output_destroy); + + group_send_output(group, output, true); +} + +void wlr_ext_workspace_group_handle_v1_output_leave( + struct wlr_ext_workspace_group_handle_v1 *group, + struct wlr_output *output) { + struct wlr_ext_workspace_v1_group_output *group_output = + get_group_output(group, output); + if (!group_output) { + return; + } + + group_send_output(group, output, false); + destroy_group_output(group_output); +} + +struct wlr_ext_workspace_handle_v1 *wlr_ext_workspace_handle_v1_create( + struct wlr_ext_workspace_manager_v1 *manager, const char *id, uint32_t caps) { + struct wlr_ext_workspace_handle_v1 *workspace = calloc(1, sizeof(*workspace)); + if (!workspace) { + return NULL; + } + + workspace->manager = manager; + workspace->caps = caps; + + if (id) { + workspace->id = strdup(id); + if (!workspace->id) { + return NULL; + } + } + + wl_list_init(&workspace->clients); + wl_array_init(&workspace->coordinates); + wl_signal_init(&workspace->events.activate); + wl_signal_init(&workspace->events.deactivate); + wl_signal_init(&workspace->events.remove); + wl_signal_init(&workspace->events.assign); + wl_signal_init(&workspace->events.destroy); + + wl_list_insert(&manager->workspaces, &workspace->link); + + struct wlr_ext_workspace_manager_client_v1 *manager_client; + wl_list_for_each(manager_client, &manager->clients, link) { + struct wlr_ext_workspace_client_v1 *workspace_client = + create_workspace_client(workspace, manager_client); + if (!workspace_client) { + continue; + } + ext_workspace_manager_v1_send_workspace( + manager_client->resource, workspace_client->resource); + workspace_send_details(workspace_client); + } + + manager_schedule_done(manager); + + return workspace; +} + +void wlr_ext_workspace_handle_v1_destroy(struct wlr_ext_workspace_handle_v1 *workspace) { + wl_signal_emit_mutable(&workspace->events.destroy, NULL); + + assert(wl_list_empty(&workspace->events.activate.listener_list)); + assert(wl_list_empty(&workspace->events.deactivate.listener_list)); + assert(wl_list_empty(&workspace->events.remove.listener_list)); + assert(wl_list_empty(&workspace->events.assign.listener_list)); + assert(wl_list_empty(&workspace->events.destroy.listener_list)); + + if (workspace->group) { + workspace_send_group(workspace, workspace->group, false); + } + + struct wlr_ext_workspace_client_v1 *workspace_client, *tmp; + wl_list_for_each_safe(workspace_client, tmp, &workspace->clients, link) { + ext_workspace_handle_v1_send_removed(workspace_client->resource); + destroy_workspace_client(workspace_client); + } + + struct wlr_ext_workspace_manager_client_v1 *manager_client; + wl_list_for_each(manager_client, &workspace->manager->clients, link) { + struct wlr_ext_workspace_v1_request *req, *tmp2; + wl_list_for_each_safe(req, tmp2, &manager_client->requests, link) { + if (req->workspace == workspace) { + destroy_request(req); + } + } + } + + manager_schedule_done(workspace->manager); + + wl_list_remove(&workspace->link); + wl_array_release(&workspace->coordinates); + free(workspace->id); + free(workspace->name); + free(workspace); +} + +void wlr_ext_workspace_handle_v1_set_group( + struct wlr_ext_workspace_handle_v1 *workspace, + struct wlr_ext_workspace_group_handle_v1 *group) { + if (workspace->group == group) { + return; + } + + if (workspace->group) { + workspace_send_group(workspace, group, false); + } + workspace->group = group; + if (group) { + workspace_send_group(workspace, group, true); + } +} + +void wlr_ext_workspace_handle_v1_set_name( + struct wlr_ext_workspace_handle_v1 *workspace, const char *name) { + assert(name); + + if (workspace->name && strcmp(workspace->name, name) == 0) { + return; + } + + free(workspace->name); + workspace->name = strdup(name); + if (workspace->name == NULL) { + return; + } + + struct wlr_ext_workspace_client_v1 *workspace_client; + wl_list_for_each(workspace_client, &workspace->clients, link) { + ext_workspace_handle_v1_send_name( + workspace_client->resource, workspace->name); + } + + manager_schedule_done(workspace->manager); +} + +static bool array_equal(struct wl_array *a, struct wl_array *b) { + return (a->size == b->size) && + (a->size == 0 || memcmp(a->data, b->data, a->size) == 0); +} + +void wlr_ext_workspace_handle_v1_set_coordinates( + struct wlr_ext_workspace_handle_v1 *workspace, + struct wl_array *coordinates) { + assert(coordinates); + + if (array_equal(&workspace->coordinates, coordinates)) { + return; + } + + wl_array_release(&workspace->coordinates); + wl_array_init(&workspace->coordinates); + wl_array_copy(&workspace->coordinates, coordinates); + + struct wlr_ext_workspace_client_v1 *workspace_client; + wl_list_for_each(workspace_client, &workspace->clients, link) { + ext_workspace_handle_v1_send_coordinates( + workspace_client->resource, &workspace->coordinates); + } + + manager_schedule_done(workspace->manager); +} + +static void workspace_set_state(struct wlr_ext_workspace_handle_v1 *workspace, + enum ext_workspace_handle_v1_state state, bool enabled) { + uint32_t old_state = workspace->state; + if (enabled) { + workspace->state |= state; + } else { + workspace->state &= ~state; + } + if (old_state == workspace->state) { + return; + } + + struct wlr_ext_workspace_client_v1 *workspace_client; + wl_list_for_each(workspace_client, &workspace->clients, link) { + ext_workspace_handle_v1_send_state( + workspace_client->resource, workspace->state); + } + + manager_schedule_done(workspace->manager); +} + +void wlr_ext_workspace_handle_v1_set_active( + struct wlr_ext_workspace_handle_v1 *workspace, bool enabled) { + workspace_set_state(workspace, EXT_WORKSPACE_HANDLE_V1_STATE_ACTIVE, enabled); +} + +void wlr_ext_workspace_handle_v1_set_urgent( + struct wlr_ext_workspace_handle_v1 *workspace, bool enabled) { + workspace_set_state(workspace, EXT_WORKSPACE_HANDLE_V1_STATE_URGENT, enabled); +} + +void wlr_ext_workspace_handle_v1_set_hidden( + struct wlr_ext_workspace_handle_v1 *workspace, bool enabled) { + workspace_set_state(workspace, EXT_WORKSPACE_HANDLE_V1_STATE_HIDDEN, enabled); +} diff --git a/src/ext-protocol/wlr_ext_workspace_v1.h b/src/ext-protocol/wlr_ext_workspace_v1.h new file mode 100644 index 0000000..ff9a052 --- /dev/null +++ b/src/ext-protocol/wlr_ext_workspace_v1.h @@ -0,0 +1,109 @@ +/* + * This an unstable interface of wlroots. No guarantees are made regarding the + * future consistency of this API. + */ +#ifndef WLR_USE_UNSTABLE +#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features" +#endif + +#ifndef WLR_TYPES_WLR_EXT_WORKSPACE_V1_H +#define WLR_TYPES_WLR_EXT_WORKSPACE_V1_H + +#include + +struct wlr_output; + +enum wlr_ext_workspace_group_handle_v1_cap { + WLR_EXT_WORKSPACE_GROUP_HANDLE_V1_CAP_CREATE_WORKSPACE = 1 << 0, +}; + +enum wlr_ext_workspace_handle_v1_cap { + WLR_EXT_WORKSPACE_HANDLE_V1_CAP_ACTIVATE = 1 << 0, + WLR_EXT_WORKSPACE_HANDLE_V1_CAP_DEACTIVATE = 1 << 1, + WLR_EXT_WORKSPACE_HANDLE_V1_CAP_REMOVE = 1 << 2, + WLR_EXT_WORKSPACE_HANDLE_V1_CAP_ASSIGN = 1 << 3, +}; + +struct wlr_ext_workspace_manager_v1 { + struct wl_global *global; + struct wl_list groups; // wlr_ext_workspace_group_handle_v1.link + struct wl_list workspaces; // wlr_ext_workspace_handle_v1.link + + struct { + struct wl_signal destroy; + } events; + + struct wl_list clients; // wlr_ext_workspace_manager_client_v1.link + struct wl_event_source *idle_source; + struct wl_event_loop *event_loop; + struct wl_listener display_destroy; +}; + +struct wlr_ext_workspace_group_handle_v1 { + struct wlr_ext_workspace_manager_v1 *manager; + uint32_t caps; // wlr_ext_workspace_group_handle_v1_cap + struct { + struct wl_signal create_workspace; // const char * + struct wl_signal destroy; + } events; + + struct wl_list link; // wlr_ext_workspace_manager_v1.groups + + struct wl_list outputs; // wlr_ext_workspace_v1_group_output.link + struct wl_list clients; // wlr_ext_workspace_manager_client_v1.link +}; + +struct wlr_ext_workspace_handle_v1 { + struct wlr_ext_workspace_manager_v1 *manager; + struct wlr_ext_workspace_group_handle_v1 *group; // May be NULL + char *id; + char *name; + struct wl_array coordinates; + uint32_t caps; // wlr_ext_workspace_handle_v1_cap + uint32_t state; // ext_workspace_handle_v1_state + + struct { + struct wl_signal activate; + struct wl_signal deactivate; + struct wl_signal remove; + struct wl_signal assign; // wlr_ext_workspace_group_handle_v1 + struct wl_signal destroy; + } events; + + struct wl_list link; // wlr_ext_workspace_manager_v1.workspaces; + + struct wl_list clients; +}; + +struct wlr_ext_workspace_manager_v1 *wlr_ext_workspace_manager_v1_create( + struct wl_display *display, uint32_t version); + +struct wlr_ext_workspace_group_handle_v1 *wlr_ext_workspace_group_handle_v1_create( + struct wlr_ext_workspace_manager_v1 *manager, uint32_t caps); +void wlr_ext_workspace_group_handle_v1_destroy( + struct wlr_ext_workspace_group_handle_v1 *group); + +void wlr_ext_workspace_group_handle_v1_output_enter( + struct wlr_ext_workspace_group_handle_v1 *group, struct wlr_output *output); +void wlr_ext_workspace_group_handle_v1_output_leave( + struct wlr_ext_workspace_group_handle_v1 *group, struct wlr_output *output); + +struct wlr_ext_workspace_handle_v1 *wlr_ext_workspace_handle_v1_create( + struct wlr_ext_workspace_manager_v1 *manager, const char *id, uint32_t caps); +void wlr_ext_workspace_handle_v1_destroy(struct wlr_ext_workspace_handle_v1 *workspace); + +void wlr_ext_workspace_handle_v1_set_group( + struct wlr_ext_workspace_handle_v1 *workspace, + struct wlr_ext_workspace_group_handle_v1 *group); +void wlr_ext_workspace_handle_v1_set_name( + struct wlr_ext_workspace_handle_v1 *workspace, const char *name); +void wlr_ext_workspace_handle_v1_set_coordinates( + struct wlr_ext_workspace_handle_v1 *workspace, struct wl_array *coordinates); +void wlr_ext_workspace_handle_v1_set_active( + struct wlr_ext_workspace_handle_v1 *workspace, bool enabled); +void wlr_ext_workspace_handle_v1_set_urgent( + struct wlr_ext_workspace_handle_v1 *workspace, bool enabled); +void wlr_ext_workspace_handle_v1_set_hidden( + struct wlr_ext_workspace_handle_v1 *workspace, bool enabled); + +#endif From c5ee61322a63352de71ccb7c2e148a18828bbe30 Mon Sep 17 00:00:00 2001 From: DreamMaoMao <2523610504@qq.com> Date: Tue, 26 Aug 2025 16:20:39 +0800 Subject: [PATCH 3/3] comment: Add a reference declaration --- LICENSE.wlroots | 21 +++++++++++++++++++++ src/ext-protocol/wlr_ext_workspace_v1.c | 4 ++++ src/ext-protocol/wlr_ext_workspace_v1.h | 4 ++++ 3 files changed, 29 insertions(+) create mode 100644 LICENSE.wlroots diff --git a/LICENSE.wlroots b/LICENSE.wlroots new file mode 100644 index 0000000..fe85581 --- /dev/null +++ b/LICENSE.wlroots @@ -0,0 +1,21 @@ +Copyright (c) 2017, 2018 Drew DeVault +Copyright (c) 2014 Jari Vetoniemi +Copyright (c) 2023 The wlroots contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +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 OR COPYRIGHT HOLDERS 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. diff --git a/src/ext-protocol/wlr_ext_workspace_v1.c b/src/ext-protocol/wlr_ext_workspace_v1.c index d2c7c16..3a698f8 100644 --- a/src/ext-protocol/wlr_ext_workspace_v1.c +++ b/src/ext-protocol/wlr_ext_workspace_v1.c @@ -1,3 +1,7 @@ +// bash on: https://gitlab.freedesktop.org/tokyo4j/wlroots/-/tree/ext-workspace +// TODO: remove this file +// refer: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/5115 + #include #include #include diff --git a/src/ext-protocol/wlr_ext_workspace_v1.h b/src/ext-protocol/wlr_ext_workspace_v1.h index ff9a052..7281bc6 100644 --- a/src/ext-protocol/wlr_ext_workspace_v1.h +++ b/src/ext-protocol/wlr_ext_workspace_v1.h @@ -1,3 +1,7 @@ +// bash on: https://gitlab.freedesktop.org/tokyo4j/wlroots/-/tree/ext-workspace +// TODO: remove this file +// refer: https://gitlab.freedesktop.org/wlroots/wlroots/-/merge_requests/5115 + /* * This an unstable interface of wlroots. No guarantees are made regarding the * future consistency of this API.