wayland-ipc.patch

1 files changed, 498 insertions, 0 deletions

diff --git a/patches/wayland-ipc.patch b/patches/wayland-ipc.patch
new file mode 100644
index 0000000..5283eaa
--- /dev/null
+++ b/patches/wayland-ipc.patch
@@ -0,0 +1,498 @@
+Add wayland protocol extenion for controlling dwl
+
+This adds a wayland protocol extension that allows clients to observe and control the window management state.
+
+Supported features:
+	* observing/updating active tags and layout
+	* observing the selected output and client
+	* updating the tags of the selected client
+
+This patch adds the .xml file and feeds it into wayland-scanner.
+
+Co-authored-by: Palanix <palanixyt@gmail.com>
+diff --git a/Makefile b/Makefile
+index ccca079..d72dea8 100644
+--- a/Makefile
++++ b/Makefile
+@@ -14,9 +14,9 @@ DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(DWLCPPFLAGS) $(DWLDEVCFLAGS) $(CF
+ LDLIBS    = `$(PKG_CONFIG) --libs $(PKGS)` $(LIBS)
+ 
+ all: dwl
+-dwl: dwl.o util.o
+-	$(CC) dwl.o util.o $(LDLIBS) $(LDFLAGS) $(DWLCFLAGS) -o $@
+-dwl.o: dwl.c config.mk config.h client.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h
++dwl: dwl.o util.o net-tapesoftware-dwl-wm-unstable-v1-protocol.o
++	$(CC) dwl.o util.o net-tapesoftware-dwl-wm-unstable-v1-protocol.o $(LDLIBS) $(LDFLAGS) $(DWLCFLAGS) -o $@
++dwl.o: dwl.c config.mk config.h client.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h net-tapesoftware-dwl-wm-unstable-v1-protocol.o
+ util.o: util.c util.h
+ 
+ # wayland-scanner is a tool which generates C headers and rigging for Wayland
+@@ -32,6 +32,14 @@ wlr-layer-shell-unstable-v1-protocol.h:
+ 	$(WAYLAND_SCANNER) server-header \
+ 		protocols/wlr-layer-shell-unstable-v1.xml $@
+ 
++net-tapesoftware-dwl-wm-unstable-v1-protocol.h: protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
++	$(WAYLAND_SCANNER) server-header \
++		protocols/net-tapesoftware-dwl-wm-unstable-v1.xml $@
++net-tapesoftware-dwl-wm-unstable-v1-protocol.c: protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
++	$(WAYLAND_SCANNER) private-code \
++		protocols/net-tapesoftware-dwl-wm-unstable-v1.xml $@
++net-tapesoftware-dwl-wm-unstable-v1-protocol.o: net-tapesoftware-dwl-wm-unstable-v1-protocol.h
++
+ config.h:
+ 	cp config.def.h $@
+ clean:
+diff --git a/dwl.c b/dwl.c
+index 8043bf9..f2977fc 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -52,6 +52,7 @@
+ #include <wlr/types/wlr_xdg_shell.h>
+ #include <wlr/util/log.h>
+ #include <xkbcommon/xkbcommon.h>
++#include "net-tapesoftware-dwl-wm-unstable-v1-protocol.h"
+ #ifdef XWAYLAND
+ #include <wlr/xwayland.h>
+ #include <X11/Xlib.h>
+@@ -172,6 +173,12 @@ typedef struct {
+ 	void (*arrange)(Monitor *);
+ } Layout;
+ 
++typedef struct {
++	struct wl_list link;
++	struct wl_resource *resource;
++	struct Monitor *monitor;
++} DwlWmMonitor;
++
+ struct Monitor {
+ 	struct wl_list link;
+ 	struct wlr_output *wlr_output;
+@@ -184,6 +191,7 @@ struct Monitor {
+ 	struct wlr_box m; /* monitor area, layout-relative */
+ 	struct wlr_box w; /* window area, layout-relative */
+ 	struct wl_list layers[4]; /* LayerSurface::link */
++	struct wl_list dwl_wm_monitor_link;
+ 	const Layout *lt[2];
+ 	unsigned int seltags;
+ 	unsigned int sellt;
+@@ -318,6 +326,10 @@ static struct wlr_scene_node *xytonode(double x, double y, struct wlr_surface **
+ 		Client **pc, LayerSurface **pl, double *nx, double *ny);
+ static void zoom(const Arg *arg);
+ 
++static void dwl_wm_bind(struct wl_client *client, void *data,
++		uint32_t version, uint32_t id);
++static void dwl_wm_printstatus(Monitor *monitor);
++
+ /* variables */
+ static const char broken[] = "broken";
+ static const char *cursor_image = "left_ptr";
+@@ -685,6 +697,7 @@ void
+ cleanupmon(struct wl_listener *listener, void *data)
+ {
+ 	Monitor *m = wl_container_of(listener, m, destroy);
++	DwlWmMonitor *mon, *montmp;
+ 	LayerSurface *l, *tmp;
+ 	int i;
+ 
+@@ -697,6 +710,10 @@ cleanupmon(struct wl_listener *listener, void *data)
+ 	wl_list_remove(&m->link);
+ 	m->wlr_output->data = NULL;
+ 	wlr_output_layout_remove(output_layout, m->wlr_output);
++	wl_list_for_each_safe(mon, montmp, &m->dwl_wm_monitor_link, link) {
++			wl_resource_set_user_data(mon->resource, NULL);
++			free(mon);
++	}
+ 	wlr_scene_output_destroy(m->scene_output);
+ 	wlr_scene_node_destroy(&m->fullscreen_bg->node);
+ 
+@@ -903,6 +920,7 @@ createmon(struct wl_listener *listener, void *data)
+ 	const MonitorRule *r;
+ 	size_t i;
+ 	Monitor *m = wlr_output->data = ecalloc(1, sizeof(*m));
++	wl_list_init(&m->dwl_wm_monitor_link);
+ 	m->wlr_output = wlr_output;
+ 
+ 	wlr_output_init_render(wlr_output, alloc, drw);
+@@ -1852,6 +1870,7 @@ printstatus(void)
+ 		printf("%s tags %u %u %u %u\n", m->wlr_output->name, occ, m->tagset[m->seltags],
+ 				sel, urg);
+ 		printf("%s layout %s\n", m->wlr_output->name, m->lt[m->sellt]->symbol);
++		dwl_wm_printstatus(m);
+ 	}
+ 	fflush(stdout);
+ }
+@@ -2289,6 +2308,7 @@ setup(void)
+ 	wl_signal_add(&output_mgr->events.test, &output_mgr_test);
+ 
+ 	wlr_scene_set_presentation(scene, wlr_presentation_create(dpy, backend));
++	wl_global_create(dpy, &znet_tapesoftware_dwl_wm_v1_interface, 1, NULL, dwl_wm_bind);
+ 
+ #ifdef XWAYLAND
+ 	/*
+@@ -2828,3 +2848,193 @@ main(int argc, char *argv[])
+ usage:
+ 	die("Usage: %s [-v] [-s startup command]", argv[0]);
+ }
++
++/* dwl_wm_monitor_v1 */
++static void
++dwl_wm_monitor_handle_release(struct wl_client *client, struct wl_resource *resource)
++{
++	wl_resource_destroy(resource);
++}
++
++static void
++dwl_wm_monitor_handle_destroy(struct wl_resource *resource)
++{
++	DwlWmMonitor *mon = wl_resource_get_user_data(resource);
++	if (mon) {
++		wl_list_remove(&mon->link);
++		free(mon);
++	}
++}
++
++static void
++dwl_wm_printstatus_to(Monitor *m, const DwlWmMonitor *mon)
++{
++	Client *c, *focused;
++	int tagmask, state, numclients, focused_client;
++	focused = focustop(m);
++	znet_tapesoftware_dwl_wm_monitor_v1_send_selected(mon->resource, m == selmon);
++
++	for (int tag = 0; tag<LENGTH(tags); tag++) {
++		numclients = state = 0;
++		focused_client = -1;
++		tagmask = 1 << tag;
++		if ((tagmask & m->tagset[m->seltags]) != 0)
++			state = state | ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_ACTIVE;
++		wl_list_for_each(c, &clients, link) {
++			if (c->mon != m)
++				continue;
++			if (!(c->tags & tagmask))
++				continue;
++			if (c == focused)
++				focused_client = numclients;
++			numclients++;
++			if (c->isurgent)
++				state = state | ZNET_TAPESOFTWARE_DWL_WM_MONITOR_V1_TAG_STATE_URGENT;
++		}
++		znet_tapesoftware_dwl_wm_monitor_v1_send_tag(mon->resource,
++			tag, state, numclients, focused_client);
++	}
++	znet_tapesoftware_dwl_wm_monitor_v1_send_layout(mon->resource, m->lt[m->sellt] - layouts);
++	znet_tapesoftware_dwl_wm_monitor_v1_send_title(mon->resource,
++		focused ? client_get_title(focused) : "");
++	znet_tapesoftware_dwl_wm_monitor_v1_send_frame(mon->resource);
++}
++
++static void
++dwl_wm_printstatus(Monitor *m)
++{
++	DwlWmMonitor *mon;
++	wl_list_for_each(mon, &m->dwl_wm_monitor_link, link) {
++		dwl_wm_printstatus_to(m, mon);
++	}
++}
++
++static void
++dwl_wm_monitor_handle_set_tags(struct wl_client *client, struct wl_resource *resource,
++	uint32_t t, uint32_t toggle_tagset)
++{
++	DwlWmMonitor *mon;
++	Monitor *m;
++	mon = wl_resource_get_user_data(resource);
++	if (!mon)
++		return;
++	m = mon->monitor;
++	if ((t & TAGMASK) == m->tagset[m->seltags])
++		return;
++	if (toggle_tagset)
++		m->seltags ^= 1;
++	if (t & TAGMASK)
++		m->tagset[m->seltags] = t & TAGMASK;
++
++	focusclient(focustop(m), 1);
++	arrange(m);
++	printstatus();
++}
++
++static void
++dwl_wm_monitor_handle_set_layout(struct wl_client *client, struct wl_resource *resource,
++	uint32_t layout)
++{
++	DwlWmMonitor *mon;
++	Monitor *m;
++	mon = wl_resource_get_user_data(resource);
++	if (!mon)
++		return;
++	m = mon->monitor;
++	if (layout >= LENGTH(layouts))
++		return;
++	if (layout != m->lt[m->sellt] - layouts)
++		m->sellt ^= 1;
++
++	m->lt[m->sellt] = &layouts[layout];
++	arrange(m);
++	printstatus();
++}
++
++static void
++dwl_wm_monitor_handle_set_client_tags(struct wl_client *client, struct wl_resource *resource,
++	uint32_t and, uint32_t xor)
++{
++	DwlWmMonitor *mon;
++	Client *sel;
++	unsigned int newtags;
++	mon = wl_resource_get_user_data(resource);
++	if (!mon)
++		return;
++	sel = focustop(mon->monitor);
++	if (!sel)
++		return;
++	newtags = (sel->tags & and) ^ xor;
++	if (newtags) {
++		sel->tags = newtags;
++		focusclient(focustop(selmon), 1);
++		arrange(selmon);
++		printstatus();
++	}
++}
++
++static const struct znet_tapesoftware_dwl_wm_monitor_v1_interface dwl_wm_monitor_implementation = {
++	.release = dwl_wm_monitor_handle_release,
++	.set_tags = dwl_wm_monitor_handle_set_tags,
++	.set_layout = dwl_wm_monitor_handle_set_layout,
++	.set_client_tags = dwl_wm_monitor_handle_set_client_tags,
++};
++
++/* dwl_wm_v1 */
++static void
++dwl_wm_handle_release(struct wl_client *client, struct wl_resource *resource)
++{
++	wl_resource_destroy(resource);
++}
++
++static void
++dwl_wm_handle_get_monitor(struct wl_client *client, struct wl_resource *resource,
++	uint32_t id, struct wl_resource *output)
++{
++	DwlWmMonitor *dwl_wm_monitor;
++	struct wlr_output *wlr_output = wlr_output_from_resource(output);
++	struct Monitor *m = wlr_output->data;
++	struct wl_resource *dwlOutputResource = wl_resource_create(client,
++		&znet_tapesoftware_dwl_wm_monitor_v1_interface, wl_resource_get_version(resource), id);
++	if (!resource) {
++		wl_client_post_no_memory(client);
++		return;
++	}
++	dwl_wm_monitor = calloc(1, sizeof(DwlWmMonitor));
++	dwl_wm_monitor->resource = dwlOutputResource;
++	dwl_wm_monitor->monitor = m;
++	wl_resource_set_implementation(dwlOutputResource, &dwl_wm_monitor_implementation,
++	dwl_wm_monitor, dwl_wm_monitor_handle_destroy);
++	wl_list_insert(&m->dwl_wm_monitor_link, &dwl_wm_monitor->link);
++	dwl_wm_printstatus_to(m, dwl_wm_monitor);
++}
++
++static void
++dwl_wm_handle_destroy(struct wl_resource *resource)
++{
++	/* no state to destroy */
++}
++
++static const struct znet_tapesoftware_dwl_wm_v1_interface dwl_wm_implementation = {
++	.release = dwl_wm_handle_release,
++	.get_monitor = dwl_wm_handle_get_monitor,
++};
++
++static void
++dwl_wm_bind(struct wl_client *client, void *data,
++	uint32_t version, uint32_t id)
++{
++	struct wl_resource *resource = wl_resource_create(client,
++		&znet_tapesoftware_dwl_wm_v1_interface, version, id);
++	if (!resource) {
++		wl_client_post_no_memory(client);
++		return;
++	}
++
++	wl_resource_set_implementation(resource, &dwl_wm_implementation, NULL, dwl_wm_handle_destroy);
++
++	for (int i = 0; i < LENGTH(tags); i++)
++		znet_tapesoftware_dwl_wm_v1_send_tag(resource, tags[i]);
++	for (int i = 0; i < LENGTH(layouts); i++)
++		znet_tapesoftware_dwl_wm_v1_send_layout(resource, layouts[i].symbol);
++}
+diff --git a/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml b/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
+new file mode 100644
+index 0000000..4fe5b73
+--- /dev/null
++++ b/protocols/net-tapesoftware-dwl-wm-unstable-v1.xml
+@@ -0,0 +1,164 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<protocol name="net_tapesoftware_dwl_wm_unstable_v1">
++    <copyright>
++        Copyright (c) 2021 Raphael Robatsch
++
++        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 (including the
++        next paragraph) 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.
++    </copyright>
++
++    <interface name="znet_tapesoftware_dwl_wm_v1" version="1">
++        <description summary="control the dwl state">
++            This interface is exposed as a global in the wl_registry.
++
++            Clients can use this protocol to receive updates of the window manager
++            state (active tags, active layout, and focused window).
++            Clients can also control this state.
++
++            After binding, the client will receive the available tags and layouts
++            with the 'tag' and 'layout' events. These can be used in subsequent
++            dwl_wm_monitor_v1.set_tags/set_layout requests, and to interpret the
++            dwl_wm_monitor_v1.layout/tag events.
++        </description>
++
++        <request name="release" type="destructor">
++            <description summary="release dwl_wm">
++                This request indicates that the client will not use the dwl_wm
++                object any more. Objects that have been created through this instance
++                are not affected.
++            </description>
++        </request>
++
++        <request name="get_monitor">
++            <description summary="gets a dwl monitor from an output">
++                Gets a dwl monitor for the specified output. The window manager
++                state on the output can be controlled using the monitor.
++            </description>
++            <arg name="id" type="new_id" interface="znet_tapesoftware_dwl_wm_monitor_v1" />
++            <arg name="output" type="object" interface="wl_output" />
++        </request>
++
++        <event name="tag">
++            <description summary="announces the presence of a tag">
++                This event is sent immediately after binding.
++                A roundtrip after binding guarantees that the client has received all tags.
++            </description>
++            <arg name="name" type="string"/>
++        </event>
++
++        <event name="layout">
++            <description summary="announces the presence of a layout">
++                This event is sent immediately after binding.
++                A roundtrip after binding guarantees that the client has received all layouts.
++            </description>
++            <arg name="name" type="string"/>
++        </event>
++    </interface>
++
++    <interface name="znet_tapesoftware_dwl_wm_monitor_v1" version="1">
++        <description summary="control one monitor">
++            Observes and controls one monitor.
++
++            Events are double-buffered: Clients should cache all events and only
++            redraw themselves once the 'frame' event is sent.
++
++            Requests are not double-buffered: The compositor will update itself
++            immediately.
++        </description>
++
++        <enum name="tag_state">
++            <entry name="none" value="0" summary="no state"/>
++            <entry name="active" value="1" summary="tag is active"/>
++            <entry name="urgent" value="2" summary="tag has at least one urgent client"/>
++        </enum>
++
++        <request name="release" type="destructor">
++            <description summary="release dwl_monitor">
++                This request indicates that the client is done with this dwl_monitor.
++                All further requests are ignored.
++            </description>
++        </request>
++
++        <event name="selected">
++            <description summary="updates the selected state of the monitor">
++                If 'selected' is nonzero, this monitor is the currently selected one.
++            </description>
++            <arg name="selected" type="uint"/>
++        </event>
++
++        <event name="tag">
++            <description summary="updates the state of one tag">
++                Announces the update of a tag. num_clients and focused_client can be
++                used to draw client indicators.
++            </description>
++            <arg name="tag" type="uint" summary="index of a tag received by the dwl_wm_v1.tag event." />
++            <arg name="state" type="uint" enum="tag_state"/>
++            <arg name="num_clients" type="uint" summary="number of clients on this tag"/>
++            <arg name="focused_client" type="int" summary="out of num_clients. -1 if there is no focused client"/>
++        </event>
++
++        <event name="layout">
++            <description summary="updates the selected layout">
++                Announces the update of the selected layout.
++            </description>
++            <arg name="layout" type="uint" summary="index of a layout received by the dwl_wm_v1.layout event."/>
++        </event>
++
++        <event name="title">
++            <description summary="updates the focused client">
++                Announces the update of the selected client.
++            </description>
++            <arg name="title" type="string"/>
++        </event>
++
++        <event name="frame">
++            <description summary="end of status update sequence">
++                Sent after all other events belonging to the status update has been sent.
++                Clients should redraw themselves now.
++            </description>
++        </event>
++
++        <request name="set_tags">
++            <description summary="sets the active tags on this monitor.">
++                Changes are applied immediately.
++            </description>
++            <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
++            <arg name="toggle_tagset" type="uint"/>
++        </request>
++
++        <request name="set_client_tags">
++            <description summary="updates the tags of the focused client.">
++                tags are updated as follows:
++                new_tags = (current_tags AND and_tags) XOR xor_tags
++
++                Changes are applied immediately.
++            </description>
++            <arg name="and_tags" type="uint"/>
++            <arg name="xor_tags" type="uint"/>
++        </request>
++
++        <request name="set_layout">
++            <description summary="sets the active layout on this monitor.">
++                Changes are applied immediately.
++            </description>
++            <arg name="layout" type="uint" summary="index of a layout received by the dwl_wm_v1.layout event."/>
++        </request>
++    </interface>
++</protocol>
+-- 
+2.39.1
+