merged foreign toplevel management

Makefile

@@ -17,12 +17,14 @@ DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(WLR_INCS) $(DWLCPPFLAGS) $(DWLDEV
 LDLIBS    = `$(PKG_CONFIG) --libs $(PKGS)` $(WLR_LIBS) -lm $(LIBS)
 
 all: dwl
-dwl: dwl.o util.o
-	$(CC) dwl.o util.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
+dwl: dwl.o util.o dwl-ipc-unstable-v2-protocol.o
+	$(CC) dwl.o util.o dwl-ipc-unstable-v2-protocol.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
 dwl.o: dwl.c client.h config.h config.mk cursor-shape-v1-protocol.h \
 	pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h \
-	wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h
+	wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h wlr-foreign-toplevel-management-unstable-v1-protocol.h \
+	dwl-ipc-unstable-v2-protocol.h
 util.o: util.c util.h
+dwl-ipc-unstable-v2-protocol.o: dwl-ipc-unstable-v2-protocol.c dwl-ipc-unstable-v2-protocol.h
 
 # wayland-scanner is a tool which generates C headers and rigging for Wayland
 # protocols, which are specified in XML. wlroots requires you to rig these up
@@ -45,6 +47,15 @@ wlr-output-power-management-unstable-v1-protocol.h:
 xdg-shell-protocol.h:
 	$(WAYLAND_SCANNER) server-header \
 		$(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
+dwl-ipc-unstable-v2-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		protocols/dwl-ipc-unstable-v2.xml $@
+dwl-ipc-unstable-v2-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		protocols/dwl-ipc-unstable-v2.xml $@
+wlr-foreign-toplevel-management-unstable-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		protocols/wlr-foreign-toplevel-management-unstable-v1.xml $@
 
 config.h:
 	cp config.def.h $@

bottomstack.patch

@@ -0,0 +1,140 @@
+From b352fb08f40b1ee2d8c4748be4922df711e3aaa9 Mon Sep 17 00:00:00 2001
+From: wochap <gean.marroquin@gmail.com>
+Date: Fri, 5 Jul 2024 10:44:29 -0500
+Subject: [PATCH] implement bottomstack
+
+---
+ config.def.h |  4 +++
+ dwl.c        | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 88 insertions(+)
+
+diff --git a/config.def.h b/config.def.h
+index 22d2171..5aac3e9 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -34,6 +34,8 @@ static const Layout layouts[] = {
+ 	{ "[]=",      tile },
+ 	{ "><>",      NULL },    /* no layout function means floating behavior */
+ 	{ "[M]",      monocle },
++	{ "TTT",      bstack },
++	{ "===",      bstackhoriz },
+ };
+ 
+ /* monitors */
+@@ -139,6 +141,8 @@ static const Key keys[] = {
+ 	{ MODKEY,                    XKB_KEY_t,          setlayout,      {.v = &layouts[0]} },
+ 	{ MODKEY,                    XKB_KEY_f,          setlayout,      {.v = &layouts[1]} },
+ 	{ MODKEY,                    XKB_KEY_m,          setlayout,      {.v = &layouts[2]} },
++	{ MODKEY,                    XKB_KEY_u,          setlayout,      {.v = &layouts[3]} },
++	{ MODKEY,                    XKB_KEY_o,          setlayout,      {.v = &layouts[4]} },
+ 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
+ 	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
+diff --git a/dwl.c b/dwl.c
+index dc0437e..5648d5f 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -57,6 +57,7 @@
+ #include <wlr/types/wlr_xdg_decoration_v1.h>
+ #include <wlr/types/wlr_xdg_output_v1.h>
+ #include <wlr/types/wlr_xdg_shell.h>
++#include <wlr/util/box.h>
+ #include <wlr/util/log.h>
+ #include <wlr/util/region.h>
+ #include <xkbcommon/xkbcommon.h>
+@@ -351,6 +352,8 @@ static Monitor *xytomon(double x, double y);
+ static void xytonode(double x, double y, struct wlr_surface **psurface,
+ 		Client **pc, LayerSurface **pl, double *nx, double *ny);
+ static void zoom(const Arg *arg);
++static void bstack(Monitor *m);
++static void bstackhoriz(Monitor *m);
+ 
+ /* variables */
+ static const char broken[] = "broken";
+@@ -3160,3 +3163,84 @@ main(int argc, char *argv[])
+ usage:
+ 	die("Usage: %s [-v] [-d] [-s startup command]", argv[0]);
+ }
++
++static void
++bstack(Monitor *m) 
++{
++	int w, h, mh, mx, tx, ty, tw;
++	int i, n = 0;
++	Client *c;
++
++	wl_list_for_each(c, &clients, link)
++		if (VISIBLEON(c, m) && !c->isfloating)
++			n++;
++	if (n == 0)
++		return;
++
++	if (n > m->nmaster) {
++		mh = (int)round(m->nmaster ? m->mfact * m->w.height : 0);
++		tw = m->w.width / (n - m->nmaster);
++		ty = m->w.y + mh;
++	} else {
++		mh = m->w.height;
++		tw = m->w.width;
++		ty = m->w.y;
++	}
++
++	i = mx = 0;
++	tx = m-> w.x;
++	wl_list_for_each(c, &clients, link) {
++		if (!VISIBLEON(c, m) || c->isfloating)
++			continue;
++		if (i < m->nmaster) {
++			w = (m->w.width - mx) / (MIN(n, m->nmaster) - i);
++			resize(c, (struct wlr_box) { .x = m->w.x + mx, .y = m->w.y, .width = w, .height = mh }, 0);
++			mx += c->geom.width;
++		} else {
++			h = m->w.height - mh;
++			resize(c, (struct wlr_box) { .x = tx, .y = ty, .width = tw, .height = h }, 0);
++			if (tw != m->w.width)
++				tx += c->geom.width;
++		}
++		i++;
++	}
++}
++
++static void
++bstackhoriz(Monitor *m) {
++	int w, mh, mx, tx, ty, th;
++	int i, n = 0;
++	Client *c;
++
++	wl_list_for_each(c, &clients, link)
++		if (VISIBLEON(c, m) && !c->isfloating)
++			n ++;
++	if (n == 0)
++		return;
++
++	if (n > m->nmaster) {
++		mh = (int)round(m->nmaster ? m->mfact * m->w.height : 0);
++		th = (m->w.height - mh) / (n - m->nmaster);
++		ty = m->w.y + mh;
++	} else {
++		th = mh = m->w.height;
++		ty = m->w.y;
++	}
++
++	i = mx = 0;
++	tx = m-> w.x;
++	wl_list_for_each(c, &clients, link) {
++		if (!VISIBLEON(c,m) || c->isfloating)
++			continue;
++		if (i < m->nmaster) {
++			w = (m->w.width - mx) / (MIN(n, m->nmaster) - i);
++			resize(c, (struct wlr_box) { .x = m->w.x + mx, .y = m->w.y, .width = w, .height = mh }, 0);
++			mx += c->geom.width;
++		} else {
++			resize(c, (struct wlr_box) { .x = tx, .y = ty, .width = m->w.width, .height = th }, 0);
++			if (th != m->w.height)
++				ty += c->geom.height;
++		}
++		i++;
++	}
++}
+-- 
+2.45.1

client.h

@@ -94,9 +94,12 @@ client_activate_surface(struct wlr_surface *s, int activated)
 {
 	struct wlr_xdg_toplevel *toplevel;
 #ifdef XWAYLAND
-	struct wlr_xwayland_surface *xsurface;
-	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
-		wlr_xwayland_surface_activate(xsurface, activated);
+	struct wlr_xwayland_surface *surface;
+	if ((surface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
+		if (activated && surface->minimized)
+			wlr_xwayland_surface_set_minimized(surface, false);
+
+		wlr_xwayland_surface_activate(surface, activated);
 		return;
 	}
 #endif
@@ -131,6 +134,18 @@ client_get_appid(Client *c)
 	return c->surface.xdg->toplevel->app_id ? c->surface.xdg->toplevel->app_id : "broken";
 }
 
+static inline int
+client_get_pid(Client *c)
+{
+	pid_t pid;
+#ifdef XWAYLAND
+	if (client_is_x11(c))
+		return c->surface.xwayland->pid;
+#endif
+	wl_client_get_credentials(c->surface.xdg->client->client, &pid, NULL, NULL);
+	return pid;
+}
+
 static inline void
 client_get_clip(Client *c, struct wlr_box *clip)
 {

config.def.h

@@ -6,6 +6,7 @@
 /* appearance */
 static const int sloppyfocus               = 1;  /* focus follows mouse */
 static const int bypass_surface_visibility = 0;  /* 1 means idle inhibitors will disable idle tracking even if it's surface isn't visible  */
+static const int smartborders              = 1;
 static const unsigned int borderpx         = 1;  /* border pixel of windows */
 static const float rootcolor[]             = COLOR(0x222222ff);
 static const float bordercolor[]           = COLOR(0x444444ff);
@@ -13,27 +14,54 @@ static const float focuscolor[]            = COLOR(0x005577ff);
 static const float urgentcolor[]           = COLOR(0xff0000ff);
 /* This conforms to the xdg-protocol. Set the alpha to zero to restore the old behavior */
 static const float fullscreen_bg[]         = {0.1f, 0.1f, 0.1f, 1.0f}; /* You can also use glsl colors */
+static int enableautoswallow = 0; /* enables autoswallowing newly spawned clients */
+static float swallowborder = 1.0f; /* add this multiplied by borderpx to border when a client is swallowed */
 
 /* tagging - TAGCOUNT must be no greater than 31 */
-#define TAGCOUNT (9)
+#define TAGCOUNT (10)
 
 /* logging */
 static int log_level = WLR_ERROR;
 
 /* NOTE: ALWAYS keep a rule declared even if you don't use rules (e.g leave at least one example) */
 static const Rule rules[] = {
-	/* app_id             title       tags mask     isfloating   monitor */
+	/* app_id                 title       tags mask     isfloating   isterm   noswallow   monitor */
 	/* examples: */
-	{ "Gimp_EXAMPLE",     NULL,       0,            1,           -1 }, /* Start on currently visible tags floating, not tiled */
-	{ "firefox_EXAMPLE",  NULL,       1 << 8,       0,           -1 }, /* Start on ONLY tag "9" */
+	{ "firefox",              NULL,                                1 << 1, 0, 0, 0, -1 },
+	{ "zen",                  NULL,                                1 << 1, 0, 0, 0, -1 },
+	{ "Lutris",               NULL,                                1 << 2, 0, 0, 0,  0 },
+	{ "zenity",               NULL,                                     0, 1, 0, 0, -1 },
+	{ "steam",                NULL,                                1 << 2, 0, 0, 0,  0 },
+	{ "discord",              NULL,                                1 << 2, 0, 0, 0,  1 },
+	{ "vesktop",              NULL,                                1 << 2, 0, 0, 0,  1 },
+	{ "TeamSpeak",            NULL,                                1 << 2, 0, 0, 0,  1 },
+	{ "Mattermost",           NULL,                                1 << 2, 0, 0, 0,  1 },
+	{ "Element",              NULL,                                1 << 2, 0, 0, 0,  1 },
+	{ "signal",               NULL,                                1 << 4, 0, 0, 0,  1 },
+	{ "telegram",             NULL,                                1 << 4, 0, 0, 0,  1 },
+	{ "Threema",              NULL,                                1 << 4, 0, 0, 0,  1 },
+	{ "Thunderbird",          NULL,                                1 << 4, 0, 0, 0,  1 },
+	{ "Sonixd",               NULL,                                1 << 8, 0, 0, 0,  1 },
+	{ "KeePassXC",            "Unlock Database - KeePassXC",       1 << 1, 1, 0, 0,  0 },
+	{ "KeePassXC",            NULL,                                1 << 9, 0, 0, 0,  0 },
+	{ "com.obsproject.Studio",NULL,                                1 << 7, 0, 0, 0,  1 },
+	{ "easyeffects",          NULL,                                1 << 9, 0, 0, 0,  1 },
+	{ "pavucontrol",          NULL,                                1 << 9, 0, 0, 0,  1 },
+        { "nextcloud",            NULL,                                     0, 1, 0, 0, -1 },
+        { "st",                   NULL,                                     0, 0, 1, 0, -1 },
+        { "vifm",                 NULL,                                     0, 0, 1, 0, -1 },
+        { "vifmrun",              NULL,                                     0, 0, 1, 0, -1 },
 };
 
 /* layout(s) */
 static const Layout layouts[] = {
 	/* symbol     arrange function */
-	{ "[]=",      tile },
-	{ "><>",      NULL },    /* no layout function means floating behavior */
-	{ "[M]",      monocle },
+	{ "M",      monocle },
+	{ "T",      tile },
+	{ "D",      deck },
+	{ "B",      bstack },
+	{ "B",      bstackhoriz },
+	{ "F",      NULL },    /* no layout function means floating behavior */
 };
 
 /* monitors */
@@ -52,12 +80,33 @@ static const MonitorRule monrules[] = {
 };
 
 /* keyboard */
-static const struct xkb_rule_names xkb_rules = {
-	/* can specify fields: rules, model, layout, variant, options */
-	/* example:
-	.options = "ctrl:nocaps",
-	*/
-	.options = NULL,
+static const struct xkb_rule_names xkb_rules[] = {
+	{
+		.layout = "de",
+	        .options = NULL,
+	},
+	{
+		.layout = "de",
+	        .variant = "nodeadkeys",
+	        .options = NULL,
+	},
+	{
+	        .layout = "de",
+	        .variant = "ru",
+	        .options = NULL,
+	}
+};
+
+/* input devices */
+static const InputRule inputrules[] = {
+	/* name                      kbcreate                 ptrcreate      */
+	/* ignore bad device - like a touchpad ;) */
+	{ "BAD DEVICE",              NULL,                    NULL                },
+	/* ungroup ydotool device - fixes a bug */
+	{ "ydotoold virtual device", createungroupedkeyboard, createpointer       },
+	/* put your touchpad name here to enable toggle touchpad */
+	{ "SYNA8020:00 06CB:CE5C Touchpad",   createkeyboard,          createtogglepointer },
+	{ NULL,                      createkeyboard,          createpointer       },
 };
 
 static const int repeat_rate = 25;
@@ -106,8 +155,10 @@ LIBINPUT_CONFIG_TAP_MAP_LMR -- 1/2/3 finger tap maps to left/middle/right
 */
 static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TAP_MAP_LRM;
 
+static const int cursor_timeout = 5;
+
 /* If you want to use the windows key for MODKEY, use WLR_MODIFIER_LOGO */
-#define MODKEY WLR_MODIFIER_ALT
+#define MODKEY WLR_MODIFIER_LOGO
 
 #define TAGKEYS(KEY,SKEY,TAG) \
 	{ MODKEY,                    KEY,            view,            {.ui = 1 << TAG} }, \
@@ -119,45 +170,66 @@ static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TA
 #define SHCMD(cmd) { .v = (const char*[]){ "/bin/sh", "-c", cmd, NULL } }
 
 /* commands */
-static const char *termcmd[] = { "foot", NULL };
-static const char *menucmd[] = { "wmenu-run", NULL };
+static const char *termcmd[] = { "st", NULL };
+static const char *filecmd[] = { "st", "-e", "vifmrun", NULL };
+static const char *menucmd[] = { "dmenu_run", "-F", "-i", "-c", "-l", "20", NULL };
 
 static const Key keys[] = {
 	/* Note that Shift changes certain key codes: c -> C, 2 -> at, etc. */
-	/* modifier                  key                 function        argument */
-	{ MODKEY,                    XKB_KEY_p,          spawn,          {.v = menucmd} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Return,     spawn,          {.v = termcmd} },
-	{ MODKEY,                    XKB_KEY_j,          focusstack,     {.i = +1} },
-	{ MODKEY,                    XKB_KEY_k,          focusstack,     {.i = -1} },
-	{ MODKEY,                    XKB_KEY_i,          incnmaster,     {.i = +1} },
-	{ MODKEY,                    XKB_KEY_d,          incnmaster,     {.i = -1} },
-	{ MODKEY,                    XKB_KEY_h,          setmfact,       {.f = -0.05f} },
-	{ MODKEY,                    XKB_KEY_l,          setmfact,       {.f = +0.05f} },
-	{ MODKEY,                    XKB_KEY_Return,     zoom,           {0} },
-	{ MODKEY,                    XKB_KEY_Tab,        view,           {0} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_C,          killclient,     {0} },
-	{ MODKEY,                    XKB_KEY_t,          setlayout,      {.v = &layouts[0]} },
-	{ MODKEY,                    XKB_KEY_f,          setlayout,      {.v = &layouts[1]} },
-	{ MODKEY,                    XKB_KEY_m,          setlayout,      {.v = &layouts[2]} },
-	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
-	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
-	{ MODKEY,                    XKB_KEY_0,          view,           {.ui = ~0} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag,            {.ui = ~0} },
-	{ MODKEY,                    XKB_KEY_comma,      focusmon,       {.i = WLR_DIRECTION_LEFT} },
-	{ MODKEY,                    XKB_KEY_period,     focusmon,       {.i = WLR_DIRECTION_RIGHT} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less,       tagmon,         {.i = WLR_DIRECTION_LEFT} },
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater,    tagmon,         {.i = WLR_DIRECTION_RIGHT} },
-	TAGKEYS(          XKB_KEY_1, XKB_KEY_exclam,                     0),
-	TAGKEYS(          XKB_KEY_2, XKB_KEY_at,                         1),
-	TAGKEYS(          XKB_KEY_3, XKB_KEY_numbersign,                 2),
-	TAGKEYS(          XKB_KEY_4, XKB_KEY_dollar,                     3),
-	TAGKEYS(          XKB_KEY_5, XKB_KEY_percent,                    4),
-	TAGKEYS(          XKB_KEY_6, XKB_KEY_asciicircum,                5),
-	TAGKEYS(          XKB_KEY_7, XKB_KEY_ampersand,                  6),
-	TAGKEYS(          XKB_KEY_8, XKB_KEY_asterisk,                   7),
-	TAGKEYS(          XKB_KEY_9, XKB_KEY_parenleft,                  8),
-	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Q,          quit,           {0} },
+	/* modifier                  key                function          argument */
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Escape,    quit,             {0} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_D,         togglefloating,   {0} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_F,         togglefullscreen, {0} },
+	{ MODKEY|WLR_MODIFIER_SHIFT|WLR_MODIFIER_CTRL,  XKB_KEY_F,    togglefakefullscreen, {0} },
+	{ MODKEY,                    XKB_KEY_h,         focusstack,       {.i = -1} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_H,         zoom,             {0} },
+	{ MODKEY,                    XKB_KEY_j,         focusstack,       {.i = +1} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_J,         incnmaster,       {.i = -1} },
+	{ MODKEY,                    XKB_KEY_k,         focusstack,       {.i = -1} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_K,         incnmaster,       {.i = +1} },
+	{ MODKEY,                    XKB_KEY_l,         focusstack,       {.i = +1} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_M,         setlayout,        {.v = &layouts[0]} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_U,         setmfact,         {.f = -0.05f} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_I,         setmfact,         {.f = -0.05f} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_O,         setmfact,         {.f = +0.05f} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_P,         setmfact,         {.f = +0.05f} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Q,         killclient,       {0} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_T,         setlayout,        {.v = &layouts[1]} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_C,         setlayout,        {.v = &layouts[2]} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_V,         setlayout,        {.v = &layouts[3]} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_S,         setlayout,        {.v = &layouts[4]} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_H,         setmfact,         {.f = -0.05f} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_L,         incxkbrules,    {.i = +1} },
+	{ MODKEY,                    XKB_KEY_comma,     focusmon,         {.i = WLR_DIRECTION_LEFT} },
+	{ MODKEY,                    XKB_KEY_period,    focusmon,         {.i = WLR_DIRECTION_RIGHT} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_semicolon, tagmon,           {.i = WLR_DIRECTION_LEFT} },
+	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_colon,     tagmon,           {.i = WLR_DIRECTION_RIGHT} },
+
+	{ MODKEY,                    XKB_KEY_r,          spawn,          {.v = menucmd} },
+	{ MODKEY,                    XKB_KEY_f,          spawn,          {.v = filecmd} },
+	{ MODKEY,                    XKB_KEY_Return,     spawn,          {.v = termcmd} },
+	{ MODKEY,                    XKB_KEY_space,      togglepointer,  {0} },
+	{ WLR_MODIFIER_ALT,          XKB_KEY_Tab,        focusstack,     {.i = +1} },
+
+        TAGKEYS(XKB_KEY_1, XKB_KEY_exclam,      0),
+        TAGKEYS(XKB_KEY_2, XKB_KEY_quotedbl,    1),
+        TAGKEYS(XKB_KEY_3, XKB_KEY_section,     2),
+        TAGKEYS(XKB_KEY_4, XKB_KEY_dollar,      3),
+        TAGKEYS(XKB_KEY_5, XKB_KEY_percent,     4),
+        TAGKEYS(XKB_KEY_6, XKB_KEY_ampersand,   5),
+        TAGKEYS(XKB_KEY_7, XKB_KEY_slash,       6),
+        TAGKEYS(XKB_KEY_8, XKB_KEY_parenleft,   7),
+        TAGKEYS(XKB_KEY_9, XKB_KEY_parenright,  8),
+        TAGKEYS(XKB_KEY_0, XKB_KEY_equal,       9),
+	// TAGKEYS(          XKB_KEY_1, XKB_KEY_exclam,                     0),
+	// TAGKEYS(          XKB_KEY_2, XKB_KEY_quotedbl,                   1),
+	// TAGKEYS(          XKB_KEY_3, XKB_KEY_paragraph,                  2),
+	// TAGKEYS(          XKB_KEY_4, XKB_KEY_dollar,                     3),
+	// TAGKEYS(          XKB_KEY_5, XKB_KEY_percent,                    4),
+	// TAGKEYS(          XKB_KEY_6, XKB_KEY_ampersand,                  5),
+	// TAGKEYS(          XKB_KEY_7, XKB_KEY_asciicircum,                6),
+	// TAGKEYS(          XKB_KEY_9, XKB_KEY_parenleft,                  7),
+	// TAGKEYS(          XKB_KEY_9, XKB_KEY_parenright,                 8),
 
 	/* Ctrl-Alt-Backspace and Ctrl-Alt-Fx used to be handled by X server */
 	{ WLR_MODIFIER_CTRL|WLR_MODIFIER_ALT,XKB_KEY_Terminate_Server, quit, {0} },

config.mk

@@ -24,11 +24,11 @@ WLR_LIBS = `$(PKG_CONFIG) --libs wlroots-0.19`
 #	-I$(PWD)/wlroots/0.19/include/wlroots-0.19
 #WLR_LIBS = -Wl,-rpath,$(PWD)/wlroots/0.19/lib64 -L$(PWD)/wlroots/0.19/lib64 -lwlroots-0.19
 
-XWAYLAND =
-XLIBS =
+# XWAYLAND =
+# XLIBS =
 # Uncomment to build XWayland support
-#XWAYLAND = -DXWAYLAND
-#XLIBS = xcb xcb-icccm
+XWAYLAND = -DXWAYLAND
+XLIBS = xcb xcb-icccm
 
 # dwl itself only uses C99 features, but wlroots' headers use anonymous unions (C11).
 # To avoid warnings about them, we do not use -std=c99 and instead of using the

deck.patch

@@ -0,0 +1,87 @@
+From d56f732d3b5bba4ea0bdf56a91d0992b0cb25bfb Mon Sep 17 00:00:00 2001
+From: anabasis <anabasis@noreply.codeberg.org>
+Date: Fri, 10 May 2024 13:45:33 -0400
+Subject: [PATCH] add deck layout
+
+---
+ config.def.h |  2 ++
+ dwl.c        | 36 ++++++++++++++++++++++++++++++++++++
+ 2 files changed, 38 insertions(+)
+
+diff --git a/config.def.h b/config.def.h
+index 8f498d2..9238da0 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -33,6 +33,7 @@ static const Layout layouts[] = {
+ 	{ "[]=",      tile },
+ 	{ "><>",      NULL },    /* no layout function means floating behavior */
+ 	{ "[M]",      monocle },
++	{ "[D]",      deck },
+ };
+ 
+ /* monitors */
+@@ -134,6 +135,7 @@ static const Key keys[] = {
+ 	{ MODKEY,                    XKB_KEY_t,          setlayout,      {.v = &layouts[0]} },
+ 	{ MODKEY,                    XKB_KEY_f,          setlayout,      {.v = &layouts[1]} },
+ 	{ MODKEY,                    XKB_KEY_m,          setlayout,      {.v = &layouts[2]} },
++	{ MODKEY,                    XKB_KEY_r,          setlayout,      {.v = &layouts[3]} },
+ 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
+ 	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
+diff --git a/dwl.c b/dwl.c
+index bf763df..1a7ce8e 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -267,6 +267,7 @@ static void createpointerconstraint(struct wl_listener *listener, void *data);
+ static void cursorconstrain(struct wlr_pointer_constraint_v1 *constraint);
+ static void cursorframe(struct wl_listener *listener, void *data);
+ static void cursorwarptohint(void);
++static void deck(Monitor *m);
+ static void destroydecoration(struct wl_listener *listener, void *data);
+ static void destroydragicon(struct wl_listener *listener, void *data);
+ static void destroyidleinhibitor(struct wl_listener *listener, void *data);
+@@ -1080,6 +1081,41 @@ cursorwarptohint(void)
+ 	}
+ }
+ 
++void
++deck(Monitor *m)
++{
++	unsigned int mw, my;
++	int i, n = 0;
++	Client *c;
++
++	wl_list_for_each(c, &clients, link)
++		if (VISIBLEON(c, m) && !c->isfloating && !c->isfullscreen)
++			n++;
++	if (n == 0)
++		return;
++
++	if (n > m->nmaster)
++		mw = m->nmaster ? ROUND(m->w.width * m->mfact) : 0;
++	else
++		mw = m->w.width;
++	i = my = 0;
++	wl_list_for_each(c, &clients, link) {
++		if (!VISIBLEON(c, m) || c->isfloating || c->isfullscreen)
++			continue;
++		if (i < m->nmaster) {
++			resize(c, (struct wlr_box){.x = m->w.x, .y = m->w.y + my, .width = mw,
++				.height = (m->w.height - my) / (MIN(n, m->nmaster) - i)}, 0);
++			my += c->geom.height;
++		} else {
++			resize(c, (struct wlr_box){.x = m->w.x + mw, .y = m->w.y,
++				.width = m->w.width - mw, .height = m->w.height}, 0);
++			if (c == focustop(m))
++				wlr_scene_node_raise_to_top(&c->scene->node);
++		}
++		i++;
++	}
++}
++
+ void
+ destroydecoration(struct wl_listener *listener, void *data)
+ {
+-- 
+2.45.0
+

en-keycodes.patch

@@ -0,0 +1,73 @@
+From cd61fac9cb6e9d0172e2f7a01e6a514d676ba5f0 Mon Sep 17 00:00:00 2001
+From: Nikita Ivanov <nikita.vyach.ivanov@gmail.com>
+Date: Tue, 4 Feb 2025 23:53:11 +0100
+Subject: [PATCH] Always use the English keymap to get keycodes
+
+---
+ dwl.c | 23 +++++++++++++++++++----
+ 1 file changed, 19 insertions(+), 4 deletions(-)
+
+diff --git a/dwl.c b/dwl.c
+index def2562..c299365 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -413,6 +413,11 @@ static struct wlr_box sgeom;
+ static struct wl_list mons;
+ static Monitor *selmon;
+ 
++static const struct xkb_rule_names en_rules = {.layout = "us"};
++static struct xkb_context *en_context;
++static struct xkb_keymap *en_keymap;
++static struct xkb_state *en_state;
++
+ #ifdef XWAYLAND
+ static void activatex11(struct wl_listener *listener, void *data);
+ static void associatex11(struct wl_listener *listener, void *data);
+@@ -694,6 +699,9 @@ cleanup(void)
+ 	wlr_backend_destroy(backend);
+ 
+ 	wl_display_destroy(dpy);
++	xkb_state_unref(en_state);
++	xkb_keymap_unref(en_keymap);
++	xkb_context_unref(en_context);
+ 	/* Destroy after the wayland display (when the monitors are already destroyed)
+ 	   to avoid destroying them with an invalid scene output. */
+ 	wlr_scene_node_destroy(&scene->tree.node);
+@@ -1582,16 +1590,19 @@ keypress(struct wl_listener *listener, void *data)
+ 	/* This event is raised when a key is pressed or released. */
+ 	KeyboardGroup *group = wl_container_of(listener, group, key);
+ 	struct wlr_keyboard_key_event *event = data;
++	int nsyms, handled;
+ 
+ 	/* Translate libinput keycode -> xkbcommon */
+ 	uint32_t keycode = event->keycode + 8;
+ 	/* Get a list of keysyms based on the keymap for this keyboard */
+ 	const xkb_keysym_t *syms;
+-	int nsyms = xkb_state_key_get_syms(
+-			group->wlr_group->keyboard.xkb_state, keycode, &syms);
+-
+-	int handled = 0;
+ 	uint32_t mods = wlr_keyboard_get_modifiers(&group->wlr_group->keyboard);
++	xkb_state_update_key(en_state, keycode,
++			(event->state == WL_KEYBOARD_KEY_STATE_PRESSED)
++			? XKB_KEY_DOWN : XKB_KEY_UP);
++	nsyms = xkb_state_key_get_syms(en_state, keycode, &syms);
++
++	handled = 0;
+ 
+ 	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
+ 
+@@ -2607,6 +2618,10 @@ setup(void)
+ 	 * pointer, touch, and drawing tablet device. We also rig up a listener to
+ 	 * let us know when new input devices are available on the backend.
+ 	 */
++	en_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
++	en_keymap = xkb_keymap_new_from_names(en_context, &en_rules,
++		XKB_KEYMAP_COMPILE_NO_FLAGS);
++	en_state = xkb_state_new(en_keymap);
+ 	LISTEN_STATIC(&backend->events.new_input, inputdevice);
+ 	virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy);
+ 	LISTEN_STATIC(&virtual_keyboard_mgr->events.new_virtual_keyboard, virtualkeyboard);
+-- 
+2.48.1
+

fakefullscreenclient.patch

@@ -0,0 +1,87 @@
+From 2ec6d0c668b4daee601337f8da45ccfa3a7d5fc6 Mon Sep 17 00:00:00 2001
+From: choc <notchoc@proton.me>
+Date: Fri, 29 Mar 2024 22:50:00 +0800
+Subject: [PATCH] implement fakefullscreenclient
+
+---
+ config.def.h |  1 +
+ dwl.c        | 23 ++++++++++++++++++++++-
+ 2 files changed, 23 insertions(+), 1 deletion(-)
+
+diff --git a/config.def.h b/config.def.h
+index 9009517..8c220eb 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -137,6 +137,7 @@ static const Key keys[] = {
+ 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
+ 	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
++	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_E,      togglefakefullscreen, {0} },
+ 	{ MODKEY,                    XKB_KEY_0,          view,           {.ui = ~0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag,            {.ui = ~0} },
+ 	{ MODKEY,                    XKB_KEY_comma,      focusmon,       {.i = WLR_DIRECTION_LEFT} },
+diff --git a/dwl.c b/dwl.c
+index 5867b0c..1e78491 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -137,7 +137,7 @@ typedef struct {
+ #endif
+ 	unsigned int bw;
+ 	uint32_t tags;
+-	int isfloating, isurgent, isfullscreen;
++	int isfloating, isurgent, isfullscreen, isfakefullscreen;
+ 	uint32_t resize; /* configure serial of a pending resize */
+ } Client;
+ 
+@@ -318,6 +318,7 @@ static void setcursor(struct wl_listener *listener, void *data);
+ static void setcursorshape(struct wl_listener *listener, void *data);
+ static void setfloating(Client *c, int floating);
+ static void setfullscreen(Client *c, int fullscreen);
++static void setfakefullscreen(Client *c, int fullscreen);
+ static void setgamma(struct wl_listener *listener, void *data);
+ static void setlayout(const Arg *arg);
+ static void setmfact(const Arg *arg);
+@@ -332,6 +333,7 @@ static void tagmon(const Arg *arg);
+ static void tile(Monitor *m);
+ static void togglefloating(const Arg *arg);
+ static void togglefullscreen(const Arg *arg);
++static void togglefakefullscreen(const Arg *arg);
+ static void toggletag(const Arg *arg);
+ static void toggleview(const Arg *arg);
+ static void unlocksession(struct wl_listener *listener, void *data);
+@@ -2181,6 +2183,17 @@ setfullscreen(Client *c, int fullscreen)
+ 	printstatus();
+ }
+ 
++void
++setfakefullscreen(Client *c, int fullscreen)
++{
++	c->isfakefullscreen = fullscreen;
++	if (!c->mon)
++		return;
++	if (c->isfullscreen)
++		setfullscreen(c, 0);
++	client_set_fullscreen(c, fullscreen);
++}
++
+ void
+ setgamma(struct wl_listener *listener, void *data)
+ {
+@@ -2620,6 +2633,14 @@ togglefullscreen(const Arg *arg)
+ 		setfullscreen(sel, !sel->isfullscreen);
+ }
+ 
++void
++togglefakefullscreen(const Arg *arg)
++{
++	Client *sel = focustop(selmon);
++	if (sel)
++		setfakefullscreen(sel, !sel->isfakefullscreen);
++}
++
+ void
+ toggletag(const Arg *arg)
+ {
+-- 
+2.44.0
+

foreign-toplevel-management.patch

@@ -0,0 +1,507 @@
+From dc63d64cd69f515013464b3feb8acb411f5a348f Mon Sep 17 00:00:00 2001
+From: wochap <gean.marroquin@gmail.com>
+Date: Thu, 2 May 2024 17:25:45 -0500
+Subject: [PATCH] implement foreign toplevel management
+
+---
+ Makefile                                      |   5 +-
+ dwl.c                                         |  93 +++++-
+ ...oreign-toplevel-management-unstable-v1.xml | 270 ++++++++++++++++++
+ 3 files changed, 366 insertions(+), 2 deletions(-)
+ create mode 100644 protocols/wlr-foreign-toplevel-management-unstable-v1.xml
+
+diff --git a/Makefile b/Makefile
+index a67fdd3..e0e1260 100644
+--- a/Makefile
++++ b/Makefile
+@@ -16,7 +16,7 @@ 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 cursor-shape-v1-protocol.h pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h xdg-shell-protocol.h
++dwl.o: dwl.c config.mk config.h client.h cursor-shape-v1-protocol.h pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h xdg-shell-protocol.h wlr-foreign-toplevel-management-unstable-v1-protocol.h
+ util.o: util.c util.h
+ 
+ # wayland-scanner is a tool which generates C headers and rigging for Wayland
+@@ -37,6 +37,9 @@ wlr-layer-shell-unstable-v1-protocol.h:
+ xdg-shell-protocol.h:
+ 	$(WAYLAND_SCANNER) server-header \
+ 		$(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
++wlr-foreign-toplevel-management-unstable-v1-protocol.h:
++	$(WAYLAND_SCANNER) server-header \
++		protocols/wlr-foreign-toplevel-management-unstable-v1.xml $@
+ 
+ config.h:
+ 	cp config.def.h $@
+diff --git a/dwl.c b/dwl.c
+index bf763df..648616d 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -22,6 +22,7 @@
+ #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_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>
+@@ -126,6 +127,11 @@ typedef struct {
+ 	struct wl_listener fullscreen;
+ 	struct wl_listener set_decoration_mode;
+ 	struct wl_listener destroy_decoration;
++	struct wlr_foreign_toplevel_handle_v1 *foreign_toplevel;
++	struct wl_listener factivate;
++	struct wl_listener fclose;
++	struct wl_listener ffullscreen;
++	struct wl_listener fdestroy;
+ 	struct wlr_box prev; /* layout-relative, includes border */
+ 	struct wlr_box bounds;
+ #ifdef XWAYLAND
+@@ -347,6 +353,11 @@ static Monitor *xytomon(double x, double y);
+ static void xytonode(double x, double y, struct wlr_surface **psurface,
+ 		Client **pc, LayerSurface **pl, double *nx, double *ny);
+ static void zoom(const Arg *arg);
++static void createforeigntoplevel(Client *c);
++static void factivatenotify(struct wl_listener *listener, void *data);
++static void fclosenotify(struct wl_listener *listener, void *data);
++static void fdestroynotify(struct wl_listener *listener, void *data);
++static void ffullscreennotify(struct wl_listener *listener, void *data);
+ 
+ /* variables */
+ static const char broken[] = "broken";
+@@ -392,6 +403,8 @@ static struct wlr_scene_rect *locked_bg;
+ static struct wlr_session_lock_v1 *cur_lock;
+ static struct wl_listener lock_listener = {.notify = locksession};
+ 
++static struct wlr_foreign_toplevel_manager_v1 *foreign_toplevel_mgr;
++
+ static struct wlr_seat *seat;
+ static KeyboardGroup kb_group = {0};
+ static KeyboardGroup vkb_group = {0};
+@@ -458,6 +471,11 @@ applyrules(Client *c)
+ 	if (!(title = client_get_title(c)))
+ 		title = broken;
+ 
++	if (c->foreign_toplevel) {
++		wlr_foreign_toplevel_handle_v1_set_app_id(c->foreign_toplevel, appid);
++		wlr_foreign_toplevel_handle_v1_set_title(c->foreign_toplevel, title);
++	}
++
+ 	for (r = rules; r < END(rules); r++) {
+ 		if ((!r->title || strstr(title, r->title))
+ 				&& (!r->id || strstr(appid, r->id))) {
+@@ -1288,6 +1306,8 @@ focusclient(Client *c, int lift)
+ 			client_set_border_color(old_c, bordercolor);
+ 
+ 			client_activate_surface(old, 0);
++			if (old_c->foreign_toplevel)
++				wlr_foreign_toplevel_handle_v1_set_activated(old_c->foreign_toplevel, 0);
+ 		}
+ 	}
+ 	printstatus();
+@@ -1306,6 +1326,8 @@ focusclient(Client *c, int lift)
+ 
+ 	/* Activate the new client */
+ 	client_activate_surface(client_surface(c), 1);
++	if (c->foreign_toplevel)
++		wlr_foreign_toplevel_handle_v1_set_activated(c->foreign_toplevel, 1);
+ }
+ 
+ void
+@@ -1599,6 +1621,8 @@ mapnotify(struct wl_listener *listener, void *data)
+ 		c->border[i]->node.data = c;
+ 	}
+ 
++	createforeigntoplevel(c);
++
+ 	/* Initialize client geometry with room for border */
+ 	client_set_tiled(c, WLR_EDGE_TOP | WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT);
+ 	c->geom.width += 2 * c->bw;
+@@ -2232,12 +2256,17 @@ setmon(Client *c, Monitor *m, uint32_t newtags)
+ 	c->prev = c->geom;
+ 
+ 	/* Scene graph sends surface leave/enter events on move and resize */
+-	if (oldmon)
++	if (oldmon) {
++		if (c->foreign_toplevel)
++			wlr_foreign_toplevel_handle_v1_output_leave(c->foreign_toplevel, oldmon->wlr_output);
+ 		arrange(oldmon);
++	}
+ 	if (m) {
+ 		/* Make sure window actually overlaps with the monitor */
+ 		resize(c, c->geom, 0);
+ 		c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */
++		if (c->foreign_toplevel)
++			wlr_foreign_toplevel_handle_v1_output_enter(c->foreign_toplevel, m->wlr_output);
+ 		setfullscreen(c, c->isfullscreen); /* This will call arrange(c->mon) */
+ 		setfloating(c, c->isfloating);
+ 	}
+@@ -2351,6 +2380,9 @@ setup(void)
+ 	gamma_control_mgr = wlr_gamma_control_manager_v1_create(dpy);
+ 	LISTEN_STATIC(&gamma_control_mgr->events.set_gamma, setgamma);
+ 
++	/* Initializes foreign toplevel management */
++	foreign_toplevel_mgr = wlr_foreign_toplevel_manager_v1_create(dpy);
++
+ 	/* Creates an output layout, which a wlroots utility for working with an
+ 	 * arrangement of screens in a physical layout. */
+ 	output_layout = wlr_output_layout_create();
+@@ -2691,6 +2723,11 @@ unmapnotify(struct wl_listener *listener, void *data)
+ 		wl_list_remove(&c->flink);
+ 	}
+ 
++	if (c->foreign_toplevel) {
++		wlr_foreign_toplevel_handle_v1_destroy(c->foreign_toplevel);
++		c->foreign_toplevel = NULL;
++	}
++
+ 	wlr_scene_node_destroy(&c->scene->node);
+ 	printstatus();
+ 	motionnotify(0, NULL, 0, 0, 0, 0);
+@@ -2802,6 +2839,12 @@ void
+ updatetitle(struct wl_listener *listener, void *data)
+ {
+ 	Client *c = wl_container_of(listener, c, set_title);
++	if (c->foreign_toplevel) {
++		const char *title;
++		if (!(title = client_get_title(c)))
++			title = broken;
++		wlr_foreign_toplevel_handle_v1_set_title(c->foreign_toplevel, title);
++	}
+ 	if (c == focustop(c->mon))
+ 		printstatus();
+ }
+@@ -2929,6 +2972,54 @@ zoom(const Arg *arg)
+ 	arrange(selmon);
+ }
+ 
++void
++createforeigntoplevel(Client *c)
++{
++	c->foreign_toplevel = wlr_foreign_toplevel_handle_v1_create(foreign_toplevel_mgr);
++
++	LISTEN(&c->foreign_toplevel->events.request_activate, &c->factivate, factivatenotify);
++	LISTEN(&c->foreign_toplevel->events.request_close, &c->fclose, fclosenotify);
++	LISTEN(&c->foreign_toplevel->events.request_fullscreen, &c->ffullscreen, ffullscreennotify);
++	LISTEN(&c->foreign_toplevel->events.destroy, &c->fdestroy, fdestroynotify);
++}
++
++void
++factivatenotify(struct wl_listener *listener, void *data)
++{
++	Client *c = wl_container_of(listener, c, factivate);
++	if (c->mon == selmon) {
++		c->tags = c->mon->tagset[c->mon->seltags];
++	} else {
++		setmon(c, selmon, 0);
++	}
++	focusclient(c, 1);
++	arrange(c->mon);
++}
++
++void
++fclosenotify(struct wl_listener *listener, void *data)
++{
++	Client *c = wl_container_of(listener, c, fclose);
++	client_send_close(c);
++}
++
++void
++ffullscreennotify(struct wl_listener *listener, void *data) {
++	Client *c = wl_container_of(listener, c, ffullscreen);
++	struct wlr_foreign_toplevel_handle_v1_fullscreen_event *event = data;
++	setfullscreen(c, event->fullscreen);
++}
++
++void
++fdestroynotify(struct wl_listener *listener, void *data)
++{
++	Client *c = wl_container_of(listener, c, fdestroy);
++	wl_list_remove(&c->factivate.link);
++	wl_list_remove(&c->fclose.link);
++	wl_list_remove(&c->ffullscreen.link);
++	wl_list_remove(&c->fdestroy.link);
++}
++
+ #ifdef XWAYLAND
+ void
+ activatex11(struct wl_listener *listener, void *data)
+diff --git a/protocols/wlr-foreign-toplevel-management-unstable-v1.xml b/protocols/wlr-foreign-toplevel-management-unstable-v1.xml
+new file mode 100644
+index 0000000..44505bb
+--- /dev/null
++++ b/protocols/wlr-foreign-toplevel-management-unstable-v1.xml
+@@ -0,0 +1,270 @@
++<?xml version="1.0" encoding="UTF-8"?>
++<protocol name="wlr_foreign_toplevel_management_unstable_v1">
++  <copyright>
++    Copyright © 2018 Ilia Bozhinov
++
++    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 appear in
++    all copies and that both that copyright notice and this permission
++    notice appear in supporting documentation, and that the name of
++    the copyright holders not be used in advertising or publicity
++    pertaining to distribution of the software without specific,
++    written prior permission.  The copyright holders make no
++    representations about the suitability of this software for any
++    purpose.  It is provided "as is" without express or implied
++    warranty.
++
++    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
++    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
++    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
++    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
++    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
++    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
++    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
++    THIS SOFTWARE.
++  </copyright>
++
++  <interface name="zwlr_foreign_toplevel_manager_v1" version="3">
++    <description summary="list and control opened apps">
++      The purpose of this protocol is to enable the creation of taskbars
++      and docks by providing them with a list of opened applications and
++      letting them request certain actions on them, like maximizing, etc.
++
++      After a client binds the zwlr_foreign_toplevel_manager_v1, each opened
++      toplevel window will be sent via the toplevel event
++    </description>
++
++    <event name="toplevel">
++      <description summary="a toplevel has been created">
++        This event is emitted whenever a new toplevel window is created. It
++        is emitted for all toplevels, regardless of the app that has created
++        them.
++
++        All initial details of the toplevel(title, app_id, states, etc.) will
++        be sent immediately after this event via the corresponding events in
++        zwlr_foreign_toplevel_handle_v1.
++      </description>
++      <arg name="toplevel" type="new_id" interface="zwlr_foreign_toplevel_handle_v1"/>
++    </event>
++
++    <request name="stop">
++      <description summary="stop sending events">
++        Indicates the client no longer wishes to receive events for new toplevels.
++        However the compositor may emit further toplevel_created events, until
++        the finished event is emitted.
++
++        The client must not send any more requests after this one.
++      </description>
++    </request>
++
++    <event name="finished" type="destructor">
++      <description summary="the compositor has finished with the toplevel manager">
++        This event indicates that the compositor is done sending events to the
++        zwlr_foreign_toplevel_manager_v1. The server will destroy the object
++        immediately after sending this request, so it will become invalid and
++        the client should free any resources associated with it.
++      </description>
++    </event>
++  </interface>
++
++  <interface name="zwlr_foreign_toplevel_handle_v1" version="3">
++    <description summary="an opened toplevel">
++      A zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel
++      window. Each app may have multiple opened toplevels.
++
++      Each toplevel has a list of outputs it is visible on, conveyed to the
++      client with the output_enter and output_leave events.
++    </description>
++
++    <event name="title">
++      <description summary="title change">
++        This event is emitted whenever the title of the toplevel changes.
++      </description>
++      <arg name="title" type="string"/>
++    </event>
++
++    <event name="app_id">
++      <description summary="app-id change">
++        This event is emitted whenever the app-id of the toplevel changes.
++      </description>
++      <arg name="app_id" type="string"/>
++    </event>
++
++    <event name="output_enter">
++      <description summary="toplevel entered an output">
++        This event is emitted whenever the toplevel becomes visible on
++        the given output. A toplevel may be visible on multiple outputs.
++      </description>
++      <arg name="output" type="object" interface="wl_output"/>
++    </event>
++
++    <event name="output_leave">
++      <description summary="toplevel left an output">
++        This event is emitted whenever the toplevel stops being visible on
++        the given output. It is guaranteed that an entered-output event
++        with the same output has been emitted before this event.
++      </description>
++      <arg name="output" type="object" interface="wl_output"/>
++    </event>
++
++    <request name="set_maximized">
++      <description summary="requests that the toplevel be maximized">
++        Requests that the toplevel be maximized. If the maximized state actually
++        changes, this will be indicated by the state event.
++      </description>
++    </request>
++
++    <request name="unset_maximized">
++      <description summary="requests that the toplevel be unmaximized">
++        Requests that the toplevel be unmaximized. If the maximized state actually
++        changes, this will be indicated by the state event.
++      </description>
++    </request>
++
++    <request name="set_minimized">
++      <description summary="requests that the toplevel be minimized">
++        Requests that the toplevel be minimized. If the minimized state actually
++        changes, this will be indicated by the state event.
++      </description>
++    </request>
++
++    <request name="unset_minimized">
++      <description summary="requests that the toplevel be unminimized">
++        Requests that the toplevel be unminimized. If the minimized state actually
++        changes, this will be indicated by the state event.
++      </description>
++    </request>
++
++    <request name="activate">
++      <description summary="activate the toplevel">
++        Request that this toplevel be activated on the given seat.
++        There is no guarantee the toplevel will be actually activated.
++      </description>
++      <arg name="seat" type="object" interface="wl_seat"/>
++    </request>
++
++    <enum name="state">
++      <description summary="types of states on the toplevel">
++        The different states that a toplevel can have. These have the same meaning
++        as the states with the same names defined in xdg-toplevel
++      </description>
++
++      <entry name="maximized"  value="0" summary="the toplevel is maximized"/>
++      <entry name="minimized"  value="1" summary="the toplevel is minimized"/>
++      <entry name="activated"  value="2" summary="the toplevel is active"/>
++      <entry name="fullscreen" value="3" summary="the toplevel is fullscreen" since="2"/>
++    </enum>
++
++    <event name="state">
++      <description summary="the toplevel state changed">
++        This event is emitted immediately after the zlw_foreign_toplevel_handle_v1
++        is created and each time the toplevel state changes, either because of a
++        compositor action or because of a request in this protocol.
++      </description>
++
++      <arg name="state" type="array"/>
++    </event>
++
++    <event name="done">
++      <description summary="all information about the toplevel has been sent">
++        This event is sent after all changes in the toplevel state have been
++        sent.
++
++        This allows changes to the zwlr_foreign_toplevel_handle_v1 properties
++        to be seen as atomic, even if they happen via multiple events.
++      </description>
++    </event>
++
++    <request name="close">
++      <description summary="request that the toplevel be closed">
++        Send a request to the toplevel to close itself. The compositor would
++        typically use a shell-specific method to carry out this request, for
++        example by sending the xdg_toplevel.close event. However, this gives
++        no guarantees the toplevel will actually be destroyed. If and when
++        this happens, the zwlr_foreign_toplevel_handle_v1.closed event will
++        be emitted.
++      </description>
++    </request>
++
++    <request name="set_rectangle">
++      <description summary="the rectangle which represents the toplevel">
++        The rectangle of the surface specified in this request corresponds to
++        the place where the app using this protocol represents the given toplevel.
++        It can be used by the compositor as a hint for some operations, e.g
++        minimizing. The client is however not required to set this, in which
++        case the compositor is free to decide some default value.
++
++        If the client specifies more than one rectangle, only the last one is
++        considered.
++
++        The dimensions are given in surface-local coordinates.
++        Setting width=height=0 removes the already-set rectangle.
++      </description>
++
++      <arg name="surface" type="object" interface="wl_surface"/>
++      <arg name="x" type="int"/>
++      <arg name="y" type="int"/>
++      <arg name="width" type="int"/>
++      <arg name="height" type="int"/>
++    </request>
++
++    <enum name="error">
++      <entry name="invalid_rectangle" value="0"
++        summary="the provided rectangle is invalid"/>
++    </enum>
++
++    <event name="closed">
++      <description summary="this toplevel has been destroyed">
++        This event means the toplevel has been destroyed. It is guaranteed there
++        won't be any more events for this zwlr_foreign_toplevel_handle_v1. The
++        toplevel itself becomes inert so any requests will be ignored except the
++        destroy request.
++      </description>
++    </event>
++
++    <request name="destroy" type="destructor">
++      <description summary="destroy the zwlr_foreign_toplevel_handle_v1 object">
++        Destroys the zwlr_foreign_toplevel_handle_v1 object.
++
++        This request should be called either when the client does not want to
++        use the toplevel anymore or after the closed event to finalize the
++        destruction of the object.
++      </description>
++    </request>
++
++    <!-- Version 2 additions -->
++
++    <request name="set_fullscreen" since="2">
++      <description summary="request that the toplevel be fullscreened">
++        Requests that the toplevel be fullscreened on the given output. If the
++        fullscreen state and/or the outputs the toplevel is visible on actually
++        change, this will be indicated by the state and output_enter/leave
++        events.
++
++        The output parameter is only a hint to the compositor. Also, if output
++        is NULL, the compositor should decide which output the toplevel will be
++        fullscreened on, if at all.
++      </description>
++      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
++    </request>
++
++    <request name="unset_fullscreen" since="2">
++      <description summary="request that the toplevel be unfullscreened">
++        Requests that the toplevel be unfullscreened. If the fullscreen state
++        actually changes, this will be indicated by the state event.
++      </description>
++    </request>
++
++    <!-- Version 3 additions -->
++
++    <event name="parent" since="3">
++      <description summary="parent change">
++        This event is emitted whenever the parent of the toplevel changes.
++
++        No event is emitted when the parent handle is destroyed by the client.
++      </description>
++      <arg name="parent" type="object" interface="zwlr_foreign_toplevel_handle_v1" allow-null="true"/>
++    </event>
++  </interface>
++</protocol>
+-- 
+2.43.2
+

hide-behind-fullscreen.patch

@@ -0,0 +1,73 @@
+From ac1537f068ea626f1984803ed8db08faf7943b18 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Leonardo=20Hern=C3=A1ndez=20Hern=C3=A1ndez?=
+ <leohdz172@proton.me>
+Date: Sun, 10 Apr 2022 22:38:53 -0500
+Subject: [PATCH] hide-behind-fullscreen
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: Leonardo Hernández Hernández <leohdz172@proton.me>
+---
+ config.def.h |  2 +-
+ dwl.c        | 24 +++++++++++++++++++++++-
+ 2 files changed, 24 insertions(+), 2 deletions(-)
+
+diff --git a/config.def.h b/config.def.h
+index 22d2171d..1d5a4c84 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -12,7 +12,7 @@ static const float bordercolor[]           = COLOR(0x444444ff);
+ static const float focuscolor[]            = COLOR(0x005577ff);
+ static const float urgentcolor[]           = COLOR(0xff0000ff);
+ /* This conforms to the xdg-protocol. Set the alpha to zero to restore the old behavior */
+-static const float fullscreen_bg[]         = {0.1f, 0.1f, 0.1f, 1.0f}; /* You can also use glsl colors */
++static const float fullscreen_bg[]         = {0.1f, 0.1f, 0.1f, 0.0f}; /* You can also use glsl colors */
+ 
+ /* tagging - TAGCOUNT must be no greater than 31 */
+ #define TAGCOUNT (9)
+diff --git a/dwl.c b/dwl.c
+index ad21e1ba..f5395fe6 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -505,7 +505,9 @@ applyrules(Client *c)
+ void
+ arrange(Monitor *m)
+ {
+-	Client *c;
++	LayerSurface *l;
++	Client *c, *sel = focustop(m);
++	int i;
+ 
+ 	if (!m->wlr_output->enabled)
+ 		return;
+@@ -536,6 +538,26 @@ arrange(Monitor *m)
+ 								: c->scene->node.parent);
+ 	}
+ 
++	if (sel && sel->isfullscreen && VISIBLEON(sel, m)) {
++		for (i = 2; i > ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND; i--) {
++			wl_list_for_each(l, &sel->mon->layers[i], link)
++				wlr_scene_node_set_enabled(&l->scene->node, 0);
++		}
++
++		wl_list_for_each(c, &clients, link) {
++			if (c->mon != m)
++				continue;
++			wlr_scene_node_set_enabled(&c->scene->node, (sel->isfullscreen && c == sel)
++					|| !sel->isfullscreen);
++		}
++	}
++	if (!sel || (!sel->isfullscreen && VISIBLEON(sel, m))) {
++		for (i = 2; i > ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND; i--) {
++			wl_list_for_each(l, &m->layers[i], link)
++				wlr_scene_node_set_enabled(&l->scene->node, 1);
++		}
++	}
++
+ 	if (m->lt[m->sellt]->arrange)
+ 		m->lt[m->sellt]->arrange(m);
+ 	motionnotify(0, NULL, 0, 0, 0, 0);
+-- 
+2.48.0
+

hide-behind-monocle.patch

@@ -0,0 +1,332 @@
+From 8022376ee59d616831271dbc9f289a8bfd4fedda Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Leonardo=20Hern=C3=A1ndez=20Hern=C3=A1ndez?=
+ <leohdz172@proton.me>
+Date: Sat, 8 Jul 2023 17:25:16 -0600
+Subject: [PATCH] hide behind monocle
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: Leonardo Hernández Hernández <leohdz172@proton.me>
+---
+ dwl.c | 87 +++++++++++++++++++++++++++++++++++++----------------------
+ 1 file changed, 55 insertions(+), 32 deletions(-)
+
+diff --git a/dwl.c b/dwl.c
+index ad21e1ba..cad3b0b2 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -285,10 +285,11 @@ static Monitor *dirtomon(enum wlr_direction dir);
+ static void focusclient(Client *c, int lift);
+ static void focusmon(const Arg *arg);
+ static void focusstack(const Arg *arg);
+-static Client *focustop(Monitor *m);
++static Client *focustop(Monitor *m, int onlytiled);
+ static void fullscreennotify(struct wl_listener *listener, void *data);
+ static void gpureset(struct wl_listener *listener, void *data);
+ static void handlesig(int signo);
++static void hidebehindmonocle(Monitor *m);
+ static void incnmaster(const Arg *arg);
+ static void inputdevice(struct wl_listener *listener, void *data);
+ static int keybinding(uint32_t mods, xkb_keysym_t sym);
+@@ -518,7 +519,7 @@ arrange(Monitor *m)
+ 	}
+ 
+ 	wlr_scene_node_set_enabled(&m->fullscreen_bg->node,
+-			(c = focustop(m)) && c->isfullscreen);
++			(c = focustop(m, 0)) && c->isfullscreen);
+ 
+ 	strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, LENGTH(m->ltsymbol));
+ 
+@@ -807,7 +808,7 @@ closemon(Monitor *m)
+ 		if (c->mon == m)
+ 			setmon(c, selmon, c->tags);
+ 	}
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ 	printstatus();
+ }
+ 
+@@ -1243,7 +1244,7 @@ void
+ destroydragicon(struct wl_listener *listener, void *data)
+ {
+ 	/* Focus enter isn't sent during drag, so refocus the focused node. */
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ 	motionnotify(0, NULL, 0, 0, 0, 0);
+ 	wl_list_remove(&listener->link);
+ }
+@@ -1280,7 +1281,7 @@ destroylock(SessionLock *lock, int unlock)
+ 
+ 	wlr_scene_node_set_enabled(&locked_bg->node, 0);
+ 
+-	focusclient(focustop(selmon), 0);
++	focusclient(focustop(selmon, 0), 0);
+ 	motionnotify(0, NULL, 0, 0, 0, 0);
+ 
+ destroy:
+@@ -1309,7 +1310,7 @@ destroylocksurface(struct wl_listener *listener, void *data)
+ 		surface = wl_container_of(cur_lock->surfaces.next, surface, link);
+ 		client_notify_enter(surface->surface, wlr_seat_get_keyboard(seat));
+ 	} else if (!locked) {
+-		focusclient(focustop(selmon), 1);
++		focusclient(focustop(selmon, 0), 1);
+ 	} else {
+ 		wlr_seat_keyboard_clear_focus(seat);
+ 	}
+@@ -1420,6 +1421,7 @@ focusclient(Client *c, int lift)
+ 		wl_list_insert(&fstack, &c->flink);
+ 		selmon = c->mon;
+ 		c->isurgent = 0;
++		hidebehindmonocle(c->mon);
+ 
+ 		/* Don't change border color if there is an exclusive focus or we are
+ 		 * handling a drag operation */
+@@ -1473,14 +1475,14 @@ focusmon(const Arg *arg)
+ 			selmon = dirtomon(arg->i);
+ 		while (!selmon->wlr_output->enabled && i++ < nmons);
+ 	}
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ }
+ 
+ void
+ focusstack(const Arg *arg)
+ {
+ 	/* Focus the next or previous client (in tiling order) on selmon */
+-	Client *c, *sel = focustop(selmon);
++	Client *c, *sel = focustop(selmon, 0);
+ 	if (!sel || (sel->isfullscreen && !client_has_children(sel)))
+ 		return;
+ 	if (arg->i > 0) {
+@@ -1506,12 +1508,15 @@ focusstack(const Arg *arg)
+  * will focus the topmost client of this mon, when actually will
+  * only return that client */
+ Client *
+-focustop(Monitor *m)
++focustop(Monitor *m, int onlytiled)
+ {
+ 	Client *c;
+ 	wl_list_for_each(c, &fstack, flink) {
+-		if (VISIBLEON(c, m))
++		if (VISIBLEON(c, m)) {
++			if (onlytiled && c->isfloating)
++				continue;
+ 			return c;
++		}
+ 	}
+ 	return NULL;
+ }
+@@ -1557,6 +1562,25 @@ handlesig(int signo)
+ 		quit(NULL);
+ }
+ 
++void
++hidebehindmonocle(Monitor *m)
++{
++	Client *c;
++	if (m && m->lt[m->sellt]->arrange == monocle) {
++		wl_list_for_each(c, &clients, link) {
++			if (c->mon != m)
++				continue;
++			wlr_scene_node_set_enabled(&c->scene->node, VISIBLEON(c, m) && c->isfloating);
++		}
++
++		c = NULL;
++
++		/* Enable top tiled client, fullscreen is considered tiled */
++		if ((c = focustop(m, 1)))
++			wlr_scene_node_set_enabled(&c->scene->node, 1);
++	}
++}
++
+ void
+ incnmaster(const Arg *arg)
+ {
+@@ -1695,7 +1719,7 @@ keyrepeat(void *data)
+ void
+ killclient(const Arg *arg)
+ {
+-	Client *sel = focustop(selmon);
++	Client *sel = focustop(selmon, 0);
+ 	if (sel)
+ 		client_send_close(sel);
+ }
+@@ -1824,8 +1848,7 @@ monocle(Monitor *m)
+ 	}
+ 	if (n)
+ 		snprintf(m->ltsymbol, LENGTH(m->ltsymbol), "[%d]", n);
+-	if ((c = focustop(m)))
+-		wlr_scene_node_raise_to_top(&c->scene->node);
++	hidebehindmonocle(m);
+ }
+ 
+ void
+@@ -2092,7 +2115,7 @@ printstatus(void)
+ 			if (c->isurgent)
+ 				urg |= c->tags;
+ 		}
+-		if ((c = focustop(m))) {
++		if ((c = focustop(m, 0))) {
+ 			printf("%s title %s\n", m->wlr_output->name, client_get_title(c));
+ 			printf("%s appid %s\n", m->wlr_output->name, client_get_appid(c));
+ 			printf("%s fullscreen %d\n", m->wlr_output->name, c->isfullscreen);
+@@ -2406,7 +2429,7 @@ setmon(Client *c, Monitor *m, uint32_t newtags)
+ 		setfullscreen(c, c->isfullscreen); /* This will call arrange(c->mon) */
+ 		setfloating(c, c->isfloating);
+ 	}
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ }
+ 
+ void
+@@ -2680,12 +2703,12 @@ startdrag(struct wl_listener *listener, void *data)
+ void
+ tag(const Arg *arg)
+ {
+-	Client *sel = focustop(selmon);
++	Client *sel = focustop(selmon, 0);
+ 	if (!sel || (arg->ui & TAGMASK) == 0)
+ 		return;
+ 
+ 	sel->tags = arg->ui & TAGMASK;
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ 	arrange(selmon);
+ 	printstatus();
+ }
+@@ -2693,7 +2716,7 @@ tag(const Arg *arg)
+ void
+ tagmon(const Arg *arg)
+ {
+-	Client *sel = focustop(selmon);
++	Client *sel = focustop(selmon, 0);
+ 	if (sel)
+ 		setmon(sel, dirtomon(arg->i), 0);
+ }
+@@ -2735,7 +2758,7 @@ tile(Monitor *m)
+ void
+ togglefloating(const Arg *arg)
+ {
+-	Client *sel = focustop(selmon);
++	Client *sel = focustop(selmon, 0);
+ 	/* return if fullscreen */
+ 	if (sel && !sel->isfullscreen)
+ 		setfloating(sel, !sel->isfloating);
+@@ -2744,7 +2767,7 @@ togglefloating(const Arg *arg)
+ void
+ togglefullscreen(const Arg *arg)
+ {
+-	Client *sel = focustop(selmon);
++	Client *sel = focustop(selmon, 0);
+ 	if (sel)
+ 		setfullscreen(sel, !sel->isfullscreen);
+ }
+@@ -2753,12 +2776,12 @@ void
+ toggletag(const Arg *arg)
+ {
+ 	uint32_t newtags;
+-	Client *sel = focustop(selmon);
++	Client *sel = focustop(selmon, 0);
+ 	if (!sel || !(newtags = sel->tags ^ (arg->ui & TAGMASK)))
+ 		return;
+ 
+ 	sel->tags = newtags;
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ 	arrange(selmon);
+ 	printstatus();
+ }
+@@ -2771,7 +2794,7 @@ toggleview(const Arg *arg)
+ 		return;
+ 
+ 	selmon->tagset[selmon->seltags] = newtagset;
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ 	arrange(selmon);
+ 	printstatus();
+ }
+@@ -2795,7 +2818,7 @@ unmaplayersurfacenotify(struct wl_listener *listener, void *data)
+ 	if (l->layer_surface->output && (l->mon = l->layer_surface->output->data))
+ 		arrangelayers(l->mon);
+ 	if (l->layer_surface->surface == seat->keyboard_state.focused_surface)
+-		focusclient(focustop(selmon), 1);
++		focusclient(focustop(selmon, 0), 1);
+ 	motionnotify(0, NULL, 0, 0, 0, 0);
+ }
+ 
+@@ -2812,7 +2835,7 @@ unmapnotify(struct wl_listener *listener, void *data)
+ 	if (client_is_unmanaged(c)) {
+ 		if (c == exclusive_focus) {
+ 			exclusive_focus = NULL;
+-			focusclient(focustop(selmon), 1);
++			focusclient(focustop(selmon, 0), 1);
+ 		}
+ 	} else {
+ 		wl_list_remove(&c->link);
+@@ -2893,7 +2916,7 @@ updatemons(struct wl_listener *listener, void *data)
+ 		/* Don't move clients to the left output when plugging monitors */
+ 		arrange(m);
+ 		/* make sure fullscreen clients have the right size */
+-		if ((c = focustop(m)) && c->isfullscreen)
++		if ((c = focustop(m, 0)) && c->isfullscreen)
+ 			resize(c, m->m, 0);
+ 
+ 		/* Try to re-set the gamma LUT when updating monitors,
+@@ -2913,7 +2936,7 @@ updatemons(struct wl_listener *listener, void *data)
+ 			if (!c->mon && client_surface(c)->mapped)
+ 				setmon(c, selmon, c->tags);
+ 		}
+-		focusclient(focustop(selmon), 1);
++		focusclient(focustop(selmon, 0), 1);
+ 		if (selmon->lock_surface) {
+ 			client_notify_enter(selmon->lock_surface->surface,
+ 					wlr_seat_get_keyboard(seat));
+@@ -2935,7 +2958,7 @@ void
+ updatetitle(struct wl_listener *listener, void *data)
+ {
+ 	Client *c = wl_container_of(listener, c, set_title);
+-	if (c == focustop(c->mon))
++	if (c == focustop(c->mon, 0))
+ 		printstatus();
+ }
+ 
+@@ -2945,7 +2968,7 @@ urgent(struct wl_listener *listener, void *data)
+ 	struct wlr_xdg_activation_v1_request_activate_event *event = data;
+ 	Client *c = NULL;
+ 	toplevel_from_wlr_surface(event->surface, &c, NULL);
+-	if (!c || c == focustop(selmon))
++	if (!c || c == focustop(selmon, 0))
+ 		return;
+ 
+ 	c->isurgent = 1;
+@@ -2963,7 +2986,7 @@ view(const Arg *arg)
+ 	selmon->seltags ^= 1; /* toggle sel tagset */
+ 	if (arg->ui & TAGMASK)
+ 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
+-	focusclient(focustop(selmon), 1);
++	focusclient(focustop(selmon, 0), 1);
+ 	arrange(selmon);
+ 	printstatus();
+ }
+@@ -3034,7 +3057,7 @@ xytonode(double x, double y, struct wlr_surface **psurface,
+ void
+ zoom(const Arg *arg)
+ {
+-	Client *c, *sel = focustop(selmon);
++	Client *c, *sel = focustop(selmon, 0);
+ 
+ 	if (!sel || !selmon || !selmon->lt[selmon->sellt]->arrange || sel->isfloating)
+ 		return;
+@@ -3145,7 +3168,7 @@ sethints(struct wl_listener *listener, void *data)
+ {
+ 	Client *c = wl_container_of(listener, c, set_hints);
+ 	struct wlr_surface *surface = client_surface(c);
+-	if (c == focustop(selmon))
++	if (c == focustop(selmon, 0))
+ 		return;
+ 
+ 	c->isurgent = xcb_icccm_wm_hints_get_urgency(c->surface.xwayland->hints);
+-- 
+2.48.0
+

inputdevicerules-v0.7.patch

@@ -0,0 +1,173 @@
+From 89f870a04f903681b0a7a0ac4eb1ae70c4984b46 Mon Sep 17 00:00:00 2001
+From: Ben Collerson <benc@benc.cc>
+Date: Sat, 15 Jun 2024 12:34:01 +1000
+Subject: [PATCH] input device rules
+
+* customise input device handling
+* ignore unwanted input devices
+* configure a toggle for an input device
+---
+ config.def.h | 13 ++++++++++
+ dwl.c        | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++--
+ 2 files changed, 79 insertions(+), 2 deletions(-)
+
+diff --git a/config.def.h b/config.def.h
+index 22d2171d..0b287ab5 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -60,6 +60,18 @@ static const struct xkb_rule_names xkb_rules = {
+ 	.options = NULL,
+ };
+ 
++/* input devices */
++static const InputRule inputrules[] = {
++	/* name                      kbcreate                 ptrcreate      */
++	/* ignore bad device - like a touchpad ;) */
++	{ "BAD DEVICE",              NULL,                    NULL                },
++	/* ungroup ydotool device - fixes a bug */
++	{ "ydotoold virtual device", createungroupedkeyboard, createpointer       },
++	/* put your touchpad name here to enable toggle touchpad */
++	{ "Elan Touchpad",           createkeyboard,          createtogglepointer },
++	{ NULL,                      createkeyboard,          createpointer       },
++};
++
+ static const int repeat_rate = 25;
+ static const int repeat_delay = 600;
+ 
+@@ -142,6 +154,7 @@ static const Key keys[] = {
+ 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
+ 	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
++	{ MODKEY,                    XKB_KEY_u,          togglepointer,  {0} },
+ 	{ MODKEY,                    XKB_KEY_0,          view,           {.ui = ~0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag,            {.ui = ~0} },
+ 	{ MODKEY,                    XKB_KEY_comma,      focusmon,       {.i = WLR_DIRECTION_LEFT} },
+diff --git a/dwl.c b/dwl.c
+index a2711f67..f6f91938 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -143,6 +143,12 @@ typedef struct {
+ 	uint32_t resize; /* configure serial of a pending resize */
+ } Client;
+ 
++typedef struct {
++	const char *name;
++	void (*kbcreate)(struct wlr_keyboard *);
++	void (*ptrcreate)(struct wlr_pointer *);
++} InputRule;
++
+ typedef struct {
+ 	uint32_t mod;
+ 	xkb_keysym_t keysym;
+@@ -270,6 +276,8 @@ static void createnotify(struct wl_listener *listener, void *data);
+ static void createpointer(struct wlr_pointer *pointer);
+ static void createpointerconstraint(struct wl_listener *listener, void *data);
+ static void createpopup(struct wl_listener *listener, void *data);
++static void createtogglepointer(struct wlr_pointer *pointer);
++static void createungroupedkeyboard(struct wlr_keyboard *keyboard);
+ static void cursorconstrain(struct wlr_pointer_constraint_v1 *constraint);
+ static void cursorframe(struct wl_listener *listener, void *data);
+ static void cursorwarptohint(void);
+@@ -340,6 +348,7 @@ static void tagmon(const Arg *arg);
+ static void tile(Monitor *m);
+ static void togglefloating(const Arg *arg);
+ static void togglefullscreen(const Arg *arg);
++static void togglepointer(const Arg *arg);
+ static void toggletag(const Arg *arg);
+ static void toggleview(const Arg *arg);
+ static void unlocksession(struct wl_listener *listener, void *data);
+@@ -413,6 +422,8 @@ static struct wlr_box sgeom;
+ static struct wl_list mons;
+ static Monitor *selmon;
+ 
++static struct libinput_device *togglepointerdevice = NULL;
++
+ #ifdef XWAYLAND
+ static void activatex11(struct wl_listener *listener, void *data);
+ static void associatex11(struct wl_listener *listener, void *data);
+@@ -1133,6 +1144,33 @@ createpopup(struct wl_listener *listener, void *data)
+ 	LISTEN_STATIC(&popup->base->surface->events.commit, commitpopup);
+ }
+ 
++void
++createtogglepointer(struct wlr_pointer *pointer)
++{
++	struct libinput_device *device;
++
++	createpointer(pointer);
++
++	if (wlr_input_device_is_libinput(&pointer->base)
++			&& (device = wlr_libinput_get_device_handle(&pointer->base))) {
++		togglepointerdevice = device;
++	}
++}
++
++void
++createungroupedkeyboard(struct wlr_keyboard *keyboard)
++{
++	/* for keyboards that need their own keyboard group */
++	KeyboardGroup *group = createkeyboardgroup();
++
++	/* Set the keymap to match the group keymap */
++	wlr_keyboard_set_keymap(keyboard, group->wlr_group->keyboard.keymap);
++	LISTEN(&keyboard->base.events.destroy, &group->destroy, destroykeyboardgroup);
++
++	/* Add the new keyboard to the group */
++	wlr_keyboard_group_add_keyboard(group->wlr_group, keyboard);
++}
++
+ void
+ cursorconstrain(struct wlr_pointer_constraint_v1 *constraint)
+ {
+@@ -1531,13 +1569,27 @@ inputdevice(struct wl_listener *listener, void *data)
+ 	 * available. */
+ 	struct wlr_input_device *device = data;
+ 	uint32_t caps;
++	const InputRule *r;
+ 
+ 	switch (device->type) {
+ 	case WLR_INPUT_DEVICE_KEYBOARD:
+-		createkeyboard(wlr_keyboard_from_input_device(device));
++		for (r = inputrules; r < END(inputrules); r++) {
++			if (!r->name || strstr(device->name, r->name)) {
++				if (r->kbcreate)
++					r->kbcreate(wlr_keyboard_from_input_device(device));
++				break;
++			}
++		}
++
+ 		break;
+ 	case WLR_INPUT_DEVICE_POINTER:
+-		createpointer(wlr_pointer_from_input_device(device));
++		for (r = inputrules; r < END(inputrules); r++) {
++			if (!r->name || strstr(device->name, r->name)) {
++				if (r->ptrcreate)
++					r->ptrcreate(wlr_pointer_from_input_device(device));
++				break;
++			}
++		}
+ 		break;
+ 	default:
+ 		/* TODO handle other input device types */
+@@ -2739,6 +2791,18 @@ togglefullscreen(const Arg *arg)
+ 		setfullscreen(sel, !sel->isfullscreen);
+ }
+ 
++void
++togglepointer(const Arg *arg)
++{
++	if (!togglepointerdevice)
++		return;
++
++	libinput_device_config_send_events_set_mode(
++		togglepointerdevice,
++		libinput_device_config_send_events_get_mode(togglepointerdevice) ^ LIBINPUT_CONFIG_SEND_EVENTS_DISABLED
++	);
++}
++
+ void
+ toggletag(const Arg *arg)
+ {
+-- 
+2.45.2
+

ipc.patch

@@ -0,0 +1,596 @@
+From 6c6d655b68770ce82a24fde9b58c4d97b672553a Mon Sep 17 00:00:00 2001
+From: choc <notchoc@proton.me>
+Date: Mon, 23 Oct 2023 10:35:17 +0800
+Subject: [PATCH] implement dwl-ipc-unstable-v2
+ https://codeberg.org/dwl/dwl-patches/wiki/ipc
+
+---
+ Makefile                          |  14 +-
+ config.def.h                      |   1 +
+ dwl.c                             | 257 ++++++++++++++++++++++++++----
+ protocols/dwl-ipc-unstable-v2.xml | 181 +++++++++++++++++++++
+ 4 files changed, 419 insertions(+), 34 deletions(-)
+ create mode 100644 protocols/dwl-ipc-unstable-v2.xml
+
+diff --git a/Makefile b/Makefile
+index 8db7409..a79a080 100644
+--- a/Makefile
++++ b/Makefile
+@@ -17,12 +17,14 @@ DWLCFLAGS = `$(PKG_CONFIG) --cflags $(PKGS)` $(WLR_INCS) $(DWLCPPFLAGS) $(DWLDEV
+ LDLIBS    = `$(PKG_CONFIG) --libs $(PKGS)` $(WLR_LIBS) -lm $(LIBS)
+
+ all: dwl
+-dwl: dwl.o util.o
+-	$(CC) dwl.o util.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
++dwl: dwl.o util.o dwl-ipc-unstable-v2-protocol.o
++	$(CC) dwl.o util.o dwl-ipc-unstable-v2-protocol.o $(DWLCFLAGS) $(LDFLAGS) $(LDLIBS) -o $@
+ dwl.o: dwl.c client.h config.h config.mk cursor-shape-v1-protocol.h \
+ 	pointer-constraints-unstable-v1-protocol.h wlr-layer-shell-unstable-v1-protocol.h \
+-	wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h
++	wlr-output-power-management-unstable-v1-protocol.h xdg-shell-protocol.h \
++	dwl-ipc-unstable-v2-protocol.h
+ util.o: util.c util.h
++dwl-ipc-unstable-v2-protocol.o: dwl-ipc-unstable-v2-protocol.c dwl-ipc-unstable-v2-protocol.h
+
+ # wayland-scanner is a tool which generates C headers and rigging for Wayland
+ # protocols, which are specified in XML. wlroots requires you to rig these up
+@@ -45,6 +47,12 @@ wlr-output-power-management-unstable-v1-protocol.h:
+ xdg-shell-protocol.h:
+ 	$(WAYLAND_SCANNER) server-header \
+ 		$(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@
++dwl-ipc-unstable-v2-protocol.h:
++	$(WAYLAND_SCANNER) server-header \
++		protocols/dwl-ipc-unstable-v2.xml $@
++dwl-ipc-unstable-v2-protocol.c:
++	$(WAYLAND_SCANNER) private-code \
++		protocols/dwl-ipc-unstable-v2.xml $@
+
+ config.h:
+ 	cp config.def.h $@
+diff --git a/config.def.h b/config.def.h
+index 22d2171..1593033 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -127,6 +127,7 @@ static const Key keys[] = {
+ 	/* modifier                  key                 function        argument */
+ 	{ MODKEY,                    XKB_KEY_p,          spawn,          {.v = menucmd} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_Return,     spawn,          {.v = termcmd} },
++	{ MODKEY,                    XKB_KEY_b,          togglebar,      {0} },
+ 	{ MODKEY,                    XKB_KEY_j,          focusstack,     {.i = +1} },
+ 	{ MODKEY,                    XKB_KEY_k,          focusstack,     {.i = -1} },
+ 	{ MODKEY,                    XKB_KEY_i,          incnmaster,     {.i = +1} },
+diff --git a/dwl.c b/dwl.c
+index 8a587d1..7a4949b 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -68,6 +68,7 @@
+ #include <xcb/xcb_icccm.h>
+ #endif
+
++#include "dwl-ipc-unstable-v2-protocol.h"
+ #include "util.h"
+
+ /* macros */
+@@ -144,6 +145,12 @@ typedef struct {
+ 	uint32_t resize; /* configure serial of a pending resize */
+ } Client;
+
++typedef struct {
++	struct wl_list link;
++	struct wl_resource *resource;
++	Monitor *mon;
++} DwlIpcOutput;
++
+ typedef struct {
+ 	uint32_t mod;
+ 	xkb_keysym_t keysym;
+@@ -189,6 +196,7 @@ typedef struct {
+
+ struct Monitor {
+ 	struct wl_list link;
++	struct wl_list dwl_ipc_outputs;
+ 	struct wlr_output *wlr_output;
+ 	struct wlr_scene_output *scene_output;
+ 	struct wlr_scene_rect *fullscreen_bg; /* See createmon() for info */
+@@ -286,6 +294,17 @@ static void destroysessionlock(struct wl_listener *listener, void *data);
+ static void destroysessionmgr(struct wl_listener *listener, void *data);
+ static void destroykeyboardgroup(struct wl_listener *listener, void *data);
+ static Monitor *dirtomon(enum wlr_direction dir);
++static void dwl_ipc_manager_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id);
++static void dwl_ipc_manager_destroy(struct wl_resource *resource);
++static void dwl_ipc_manager_get_output(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *output);
++static void dwl_ipc_manager_release(struct wl_client *client, struct wl_resource *resource);
++static void dwl_ipc_output_destroy(struct wl_resource *resource);
++static void dwl_ipc_output_printstatus(Monitor *monitor);
++static void dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output);
++static void dwl_ipc_output_set_client_tags(struct wl_client *client, struct wl_resource *resource, uint32_t and_tags, uint32_t xor_tags);
++static void dwl_ipc_output_set_layout(struct wl_client *client, struct wl_resource *resource, uint32_t index);
++static void dwl_ipc_output_set_tags(struct wl_client *client, struct wl_resource *resource, uint32_t tagmask, uint32_t toggle_tagset);
++static void dwl_ipc_output_release(struct wl_client *client, struct wl_resource *resource);
+ static void focusclient(Client *c, int lift);
+ static void focusmon(const Arg *arg);
+ static void focusstack(const Arg *arg);
+@@ -338,6 +357,7 @@ static void startdrag(struct wl_listener *listener, void *data);
+ static void tag(const Arg *arg);
+ static void tagmon(const Arg *arg);
+ static void tile(Monitor *m);
++static void togglebar(const Arg *arg);
+ static void togglefloating(const Arg *arg);
+ static void togglefullscreen(const Arg *arg);
+ static void toggletag(const Arg *arg);
+@@ -411,6 +431,9 @@ static struct wlr_box sgeom;
+ static struct wl_list mons;
+ static Monitor *selmon;
+
++static struct zdwl_ipc_manager_v2_interface dwl_manager_implementation = {.release = dwl_ipc_manager_release, .get_output = dwl_ipc_manager_get_output};
++static struct zdwl_ipc_output_v2_interface dwl_output_implementation = {.release = dwl_ipc_output_release, .set_tags = dwl_ipc_output_set_tags, .set_layout = dwl_ipc_output_set_layout, .set_client_tags = dwl_ipc_output_set_client_tags};
++
+ #ifdef XWAYLAND
+ static void activatex11(struct wl_listener *listener, void *data);
+ static void associatex11(struct wl_listener *listener, void *data);
+@@ -703,6 +726,10 @@ cleanupmon(struct wl_listener *listener, void *data)
+ 	LayerSurface *l, *tmp;
+ 	size_t i;
+
++	DwlIpcOutput *ipc_output, *ipc_output_tmp;
++	wl_list_for_each_safe(ipc_output, ipc_output_tmp, &m->dwl_ipc_outputs, link)
++		wl_resource_destroy(ipc_output->resource);
++
+ 	/* m->layers[i] are intentionally not unlinked */
+ 	for (i = 0; i < LENGTH(m->layers); i++) {
+ 		wl_list_for_each_safe(l, tmp, &m->layers[i], link)
+@@ -983,6 +1010,8 @@ createmon(struct wl_listener *listener, void *data)
+ 	m = wlr_output->data = ecalloc(1, sizeof(*m));
+ 	m->wlr_output = wlr_output;
+
++	wl_list_init(&m->dwl_ipc_outputs);
++
+ 	for (i = 0; i < LENGTH(m->layers); i++)
+ 		wl_list_init(&m->layers[i]);
+
+@@ -1334,6 +1363,192 @@ dirtomon(enum wlr_direction dir)
+ 	return selmon;
+ }
+
++void
++dwl_ipc_manager_bind(struct wl_client *client, void *data, uint32_t version, uint32_t id)
++{
++	struct wl_resource *manager_resource = wl_resource_create(client, &zdwl_ipc_manager_v2_interface, version, id);
++	if (!manager_resource) {
++		wl_client_post_no_memory(client);
++		return;
++	}
++	wl_resource_set_implementation(manager_resource, &dwl_manager_implementation, NULL, dwl_ipc_manager_destroy);
++
++	zdwl_ipc_manager_v2_send_tags(manager_resource, TAGCOUNT);
++
++	for (unsigned int i = 0; i < LENGTH(layouts); i++)
++		zdwl_ipc_manager_v2_send_layout(manager_resource, layouts[i].symbol);
++}
++
++void
++dwl_ipc_manager_destroy(struct wl_resource *resource)
++{
++	/* No state to destroy */
++}
++
++void
++dwl_ipc_manager_get_output(struct wl_client *client, struct wl_resource *resource, uint32_t id, struct wl_resource *output)
++{
++	DwlIpcOutput *ipc_output;
++	Monitor *monitor = wlr_output_from_resource(output)->data;
++	struct wl_resource *output_resource = wl_resource_create(client, &zdwl_ipc_output_v2_interface, wl_resource_get_version(resource), id);
++	if (!output_resource)
++		return;
++
++	ipc_output = ecalloc(1, sizeof(*ipc_output));
++	ipc_output->resource = output_resource;
++	ipc_output->mon = monitor;
++	wl_resource_set_implementation(output_resource, &dwl_output_implementation, ipc_output, dwl_ipc_output_destroy);
++	wl_list_insert(&monitor->dwl_ipc_outputs, &ipc_output->link);
++	dwl_ipc_output_printstatus_to(ipc_output);
++}
++
++void
++dwl_ipc_manager_release(struct wl_client *client, struct wl_resource *resource)
++{
++	wl_resource_destroy(resource);
++}
++
++static void
++dwl_ipc_output_destroy(struct wl_resource *resource)
++{
++	DwlIpcOutput *ipc_output = wl_resource_get_user_data(resource);
++	wl_list_remove(&ipc_output->link);
++	free(ipc_output);
++}
++
++void
++dwl_ipc_output_printstatus(Monitor *monitor)
++{
++	DwlIpcOutput *ipc_output;
++	wl_list_for_each(ipc_output, &monitor->dwl_ipc_outputs, link)
++		dwl_ipc_output_printstatus_to(ipc_output);
++}
++
++void
++dwl_ipc_output_printstatus_to(DwlIpcOutput *ipc_output)
++{
++	Monitor *monitor = ipc_output->mon;
++	Client *c, *focused;
++	int tagmask, state, numclients, focused_client, tag;
++	const char *title, *appid;
++	focused = focustop(monitor);
++	zdwl_ipc_output_v2_send_active(ipc_output->resource, monitor == selmon);
++
++	for (tag = 0 ; tag < TAGCOUNT; tag++) {
++		numclients = state = focused_client = 0;
++		tagmask = 1 << tag;
++		if ((tagmask & monitor->tagset[monitor->seltags]) != 0)
++			state |= ZDWL_IPC_OUTPUT_V2_TAG_STATE_ACTIVE;
++
++		wl_list_for_each(c, &clients, link) {
++			if (c->mon != monitor)
++				continue;
++			if (!(c->tags & tagmask))
++				continue;
++			if (c == focused)
++				focused_client = 1;
++			if (c->isurgent)
++				state |= ZDWL_IPC_OUTPUT_V2_TAG_STATE_URGENT;
++
++			numclients++;
++		}
++		zdwl_ipc_output_v2_send_tag(ipc_output->resource, tag, state, numclients, focused_client);
++	}
++	title = focused ? client_get_title(focused) : "";
++	appid = focused ? client_get_appid(focused) : "";
++
++	zdwl_ipc_output_v2_send_layout(ipc_output->resource, monitor->lt[monitor->sellt] - layouts);
++	zdwl_ipc_output_v2_send_title(ipc_output->resource, title);
++	zdwl_ipc_output_v2_send_appid(ipc_output->resource, appid);
++	zdwl_ipc_output_v2_send_layout_symbol(ipc_output->resource, monitor->ltsymbol);
++	if (wl_resource_get_version(ipc_output->resource) >= ZDWL_IPC_OUTPUT_V2_FULLSCREEN_SINCE_VERSION) {
++		zdwl_ipc_output_v2_send_fullscreen(ipc_output->resource, focused ? focused->isfullscreen : 0);
++	}
++	if (wl_resource_get_version(ipc_output->resource) >= ZDWL_IPC_OUTPUT_V2_FLOATING_SINCE_VERSION) {
++		zdwl_ipc_output_v2_send_floating(ipc_output->resource, focused ? focused->isfloating : 0);
++	}
++	zdwl_ipc_output_v2_send_frame(ipc_output->resource);
++}
++
++void
++dwl_ipc_output_set_client_tags(struct wl_client *client, struct wl_resource *resource, uint32_t and_tags, uint32_t xor_tags)
++{
++	DwlIpcOutput *ipc_output;
++	Monitor *monitor;
++	Client *selected_client;
++	unsigned int newtags = 0;
++
++	ipc_output = wl_resource_get_user_data(resource);
++	if (!ipc_output)
++		return;
++
++	monitor = ipc_output->mon;
++	selected_client = focustop(monitor);
++	if (!selected_client)
++		return;
++
++	newtags = (selected_client->tags & and_tags) ^ xor_tags;
++	if (!newtags)
++		return;
++
++	selected_client->tags = newtags;
++	if (selmon == monitor)
++		focusclient(focustop(monitor), 1);
++	arrange(selmon);
++	printstatus();
++}
++
++void
++dwl_ipc_output_set_layout(struct wl_client *client, struct wl_resource *resource, uint32_t index)
++{
++	DwlIpcOutput *ipc_output;
++	Monitor *monitor;
++
++	ipc_output = wl_resource_get_user_data(resource);
++	if (!ipc_output)
++		return;
++
++	monitor = ipc_output->mon;
++	if (index >= LENGTH(layouts))
++		return;
++	if (index != monitor->lt[monitor->sellt] - layouts)
++		monitor->sellt ^= 1;
++
++	monitor->lt[monitor->sellt] = &layouts[index];
++	arrange(monitor);
++	printstatus();
++}
++
++void
++dwl_ipc_output_set_tags(struct wl_client *client, struct wl_resource *resource, uint32_t tagmask, uint32_t toggle_tagset)
++{
++	DwlIpcOutput *ipc_output;
++	Monitor *monitor;
++	unsigned int newtags = tagmask & TAGMASK;
++
++	ipc_output = wl_resource_get_user_data(resource);
++	if (!ipc_output)
++		return;
++	monitor = ipc_output->mon;
++
++	if (!newtags || newtags == monitor->tagset[monitor->seltags])
++		return;
++	if (toggle_tagset)
++		monitor->seltags ^= 1;
++
++	monitor->tagset[monitor->seltags] = newtags;
++	if (selmon == monitor)
++		focusclient(focustop(monitor), 1);
++	arrange(monitor);
++	printstatus();
++}
++
++void
++dwl_ipc_output_release(struct wl_client *client, struct wl_resource *resource)
++{
++	wl_resource_destroy(resource);
++}
++
+ void
+ focusclient(Client *c, int lift)
+ {
+@@ -2033,38 +2248,9 @@ void
+ printstatus(void)
+ {
+ 	Monitor *m = NULL;
+-	Client *c;
+-	uint32_t occ, urg, sel;
+
+-	wl_list_for_each(m, &mons, link) {
+-		occ = urg = 0;
+-		wl_list_for_each(c, &clients, link) {
+-			if (c->mon != m)
+-				continue;
+-			occ |= c->tags;
+-			if (c->isurgent)
+-				urg |= c->tags;
+-		}
+-		if ((c = focustop(m))) {
+-			printf("%s title %s\n", m->wlr_output->name, client_get_title(c));
+-			printf("%s appid %s\n", m->wlr_output->name, client_get_appid(c));
+-			printf("%s fullscreen %d\n", m->wlr_output->name, c->isfullscreen);
+-			printf("%s floating %d\n", m->wlr_output->name, c->isfloating);
+-			sel = c->tags;
+-		} else {
+-			printf("%s title \n", m->wlr_output->name);
+-			printf("%s appid \n", m->wlr_output->name);
+-			printf("%s fullscreen \n", m->wlr_output->name);
+-			printf("%s floating \n", m->wlr_output->name);
+-			sel = 0;
+-		}
+-
+-		printf("%s selmon %u\n", m->wlr_output->name, m == selmon);
+-		printf("%s tags %"PRIu32" %"PRIu32" %"PRIu32" %"PRIu32"\n",
+-			m->wlr_output->name, occ, m->tagset[m->seltags], sel, urg);
+-		printf("%s layout %s\n", m->wlr_output->name, m->ltsymbol);
+-	}
+-	fflush(stdout);
++	wl_list_for_each(m, &mons, link)
++		dwl_ipc_output_printstatus(m);
+ }
+
+ void
+@@ -2584,6 +2770,8 @@ setup(void)
+ 	LISTEN_STATIC(&output_mgr->events.apply, outputmgrapply);
+ 	LISTEN_STATIC(&output_mgr->events.test, outputmgrtest);
+
++	wl_global_create(dpy, &zdwl_ipc_manager_v2_interface, 2, NULL, dwl_ipc_manager_bind);
++
+ 	/* Make sure XWayland clients don't connect to the parent X server,
+ 	 * e.g when running in the x11 backend or the wayland backend and the
+ 	 * compositor has Xwayland support */
+@@ -2681,6 +2869,13 @@ tile(Monitor *m)
+ 	}
+ }
+
++void
++togglebar(const Arg *arg) {
++	DwlIpcOutput *ipc_output;
++	wl_list_for_each(ipc_output, &selmon->dwl_ipc_outputs, link)
++		zdwl_ipc_output_v2_send_toggle_visibility(ipc_output->resource);
++}
++
+ void
+ togglefloating(const Arg *arg)
+ {
+diff --git a/protocols/dwl-ipc-unstable-v2.xml b/protocols/dwl-ipc-unstable-v2.xml
+new file mode 100644
+index 0000000..0a6e7e5
+--- /dev/null
++++ b/protocols/dwl-ipc-unstable-v2.xml
+@@ -0,0 +1,181 @@
++<?xml version="1.0" encoding="utf-8"?>
++<!--
++This is largely ripped from somebar's ipc patchset; just with some personal modifications.
++I would probably just submit raphi's patchset but I don't think that would be polite.
++-->
++<protocol name="dwl_ipc_unstable_v2">
++  <description summary="inter-proccess-communication about dwl's state">
++      This protocol allows clients to update and get updates from dwl.
++
++      Warning! The protocol described in this file is experimental and
++      backward incompatible changes may be made. Backward compatible
++      changes may be added together with the corresponding interface
++      version bump.
++      Backward incompatible changes are done by bumping the version
++      number in the protocol and interface names and resetting the
++      interface version. Once the protocol is to be declared stable,
++      the 'z' prefix and the version number in the protocol and
++      interface names are removed and the interface version number is
++      reset.
++  </description>
++
++  <interface name="zdwl_ipc_manager_v2" version="2">
++    <description summary="manage dwl state">
++      This interface is exposed as a global in wl_registry.
++
++      Clients can use this interface to get a dwl_ipc_output.
++      After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
++      The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
++    </description>
++
++    <request name="release" type="destructor">
++      <description summary="release dwl_ipc_manager">
++        Indicates that the client will not the dwl_ipc_manager object anymore.
++        Objects created through this instance are not affected.
++      </description>
++    </request>
++
++    <request name="get_output">
++      <description summary="get a dwl_ipc_outout for a wl_output">
++        Get a dwl_ipc_outout for the specified wl_output.
++      </description>
++      <arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/>
++      <arg name="output" type="object" interface="wl_output"/>
++    </request>
++
++    <event name="tags">
++      <description summary="Announces tag amount">
++        This event is sent after binding.
++        A roundtrip after binding guarantees the client recieved all tags.
++      </description>
++      <arg name="amount" type="uint"/>
++    </event>
++
++    <event name="layout">
++      <description summary="Announces a layout">
++        This event is sent after binding.
++        A roundtrip after binding guarantees the client recieved all layouts.
++      </description>
++      <arg name="name" type="string"/>
++    </event>
++  </interface>
++
++  <interface name="zdwl_ipc_output_v2" version="2">
++    <description summary="control dwl output">
++      Observe and control a dwl output.
++
++      Events are double-buffered:
++      Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
++
++      Request are not double-buffered:
++      The compositor will update immediately upon request.
++    </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_ipc_outout">
++        Indicates to that the client no longer needs this dwl_ipc_output.
++      </description>
++    </request>
++
++    <event name="toggle_visibility">
++      <description summary="Toggle client visibilty">
++        Indicates the client should hide or show themselves.
++        If the client is visible then hide, if hidden then show.
++      </description>
++    </event>
++
++    <event name="active">
++      <description summary="Update the selected output.">
++        Indicates if the output is active. Zero is invalid, nonzero is valid.
++      </description>
++      <arg name="active" type="uint"/>
++    </event>
++
++    <event name="tag">
++      <description summary="Update the state of a tag.">
++        Indicates that a tag has been updated.
++      </description>
++      <arg name="tag" type="uint" summary="Index of the tag"/>
++      <arg name="state" type="uint" enum="tag_state" summary="The state of the tag."/>
++      <arg name="clients" type="uint" summary="The number of clients in the tag."/>
++      <arg name="focused" type="uint" summary="If there is a focused client. Nonzero being valid, zero being invalid."/>
++    </event>
++
++    <event name="layout">
++      <description summary="Update the layout.">
++        Indicates a new layout is selected.
++      </description>
++      <arg name="layout" type="uint" summary="Index of the layout."/>
++    </event>
++
++    <event name="title">
++      <description summary="Update the title.">
++        Indicates the title has changed.
++      </description>
++      <arg name="title" type="string" summary="The new title name."/>
++    </event>
++
++    <event name="appid" since="1">
++      <description summary="Update the appid.">
++        Indicates the appid has changed.
++      </description>
++      <arg name="appid" type="string" summary="The new appid."/>
++    </event>
++
++    <event name="layout_symbol" since="1">
++      <description summary="Update the current layout symbol">
++          Indicates the layout has changed. Since layout symbols are dynamic.
++          As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying.
++          You can ignore the zdwl_ipc_output.layout event.
++      </description>
++      <arg name="layout" type="string" summary="The new layout"/>
++    </event>
++
++    <event name="frame">
++      <description summary="The update sequence is done.">
++        Indicates that a sequence of status updates have finished and the client should redraw.
++      </description>
++    </event>
++
++    <request name="set_tags">
++      <description summary="Set the active tags of this output"/>
++      <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
++      <arg name="toggle_tagset" type="uint" summary="toggle the selected tagset, zero for invalid, nonzero for valid."/>
++    </request>
++
++    <request name="set_client_tags">
++      <description summary="Set the tags of the focused client.">
++        The tags are updated as follows:
++        new_tags = (current_tags AND and_tags) XOR xor_tags
++      </description>
++      <arg name="and_tags" type="uint"/>
++      <arg name="xor_tags" type="uint"/>
++    </request>
++
++    <request name="set_layout">
++      <description summary="Set the layout of this output"/>
++      <arg name="index" type="uint" summary="index of a layout recieved by dwl_ipc_manager.layout"/>
++    </request>
++
++    <!-- Version 2 -->
++    <event name="fullscreen" since="2">
++      <description summary="Update fullscreen status">
++          Indicates if the selected client on this output is fullscreen.
++      </description>
++      <arg name="is_fullscreen" type="uint" summary="If the selected client is fullscreen. Nonzero is valid, zero invalid"/>
++    </event>
++
++    <event name="floating" since="2">
++      <description summary="Update the floating status">
++          Indicates if the selected client on this output is floating.
++      </description>
++      <arg name="is_floating" type="uint" summary="If the selected client is floating. Nonzero is valid, zero invalid"/>
++    </event>
++  </interface>
++</protocol>
+--
+2.43.0

pertag.patch

@@ -0,0 +1,170 @@
+From d3b551ffe3ec85e16341962e322150b81af6722f Mon Sep 17 00:00:00 2001
+From: wochap <gean.marroquin@gmail.com>
+Date: Wed, 31 Jul 2024 08:27:26 -0500
+Subject: [PATCH] makes layout, mwfact and nmaster individual for every tag
+
+inspiration: https://github.com/djpohly/dwl/wiki/pertag
+---
+ dwl.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++----
+ 1 file changed, 70 insertions(+), 5 deletions(-)
+
+diff --git a/dwl.c b/dwl.c
+index 145fd01..2f364bc 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -102,6 +102,7 @@ typedef struct {
+ 	const Arg arg;
+ } Button;
+ 
++typedef struct Pertag Pertag;
+ typedef struct Monitor Monitor;
+ typedef struct {
+ 	/* Must keep these three elements in this order */
+@@ -199,6 +200,7 @@ struct Monitor {
+ 	struct wlr_box w; /* window area, layout-relative */
+ 	struct wl_list layers[4]; /* LayerSurface.link */
+ 	const Layout *lt[2];
++	Pertag *pertag;
+ 	unsigned int seltags;
+ 	unsigned int sellt;
+ 	uint32_t tagset[2];
+@@ -427,6 +429,14 @@ static xcb_atom_t netatom[NetLast];
+ /* attempt to encapsulate suck into one file */
+ #include "client.h"
+ 
++struct Pertag {
++	unsigned int curtag, prevtag; /* current and previous tag */
++	int nmasters[TAGCOUNT + 1]; /* number of windows in master area */
++	float mfacts[TAGCOUNT + 1]; /* mfacts per tag */
++	unsigned int sellts[TAGCOUNT + 1]; /* selected layouts */
++	const Layout *ltidxs[TAGCOUNT + 1][2]; /* matrix of tags and layouts indexes  */
++};
++
+ /* function implementations */
+ void
+ applybounds(Client *c, struct wlr_box *bbox)
+@@ -712,6 +722,7 @@ cleanupmon(struct wl_listener *listener, void *data)
+ 	wlr_output_layout_remove(output_layout, m->wlr_output);
+ 	wlr_scene_output_destroy(m->scene_output);
+ 
++	free(m->pertag);
+ 	closemon(m);
+ 	wlr_scene_node_destroy(&m->fullscreen_bg->node);
+ 	free(m);
+@@ -983,6 +994,18 @@ createmon(struct wl_listener *listener, void *data)
+ 	wl_list_insert(&mons, &m->link);
+ 	printstatus();
+ 
++	m->pertag = calloc(1, sizeof(Pertag));
++	m->pertag->curtag = m->pertag->prevtag = 1;
++
++	for (i = 0; i <= TAGCOUNT; i++) {
++		m->pertag->nmasters[i] = m->nmaster;
++		m->pertag->mfacts[i] = m->mfact;
++
++		m->pertag->ltidxs[i][0] = m->lt[0];
++		m->pertag->ltidxs[i][1] = m->lt[1];
++		m->pertag->sellts[i] = m->sellt;
++	}
++
+ 	/* The xdg-protocol specifies:
+ 	 *
+ 	 * If the fullscreened surface is not opaque, the compositor must make
+@@ -1472,7 +1495,7 @@ incnmaster(const Arg *arg)
+ {
+ 	if (!arg || !selmon)
+ 		return;
+-	selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag] = MAX(selmon->nmaster + arg->i, 0);
+ 	arrange(selmon);
+ }
+ 
+@@ -2305,9 +2328,9 @@ setlayout(const Arg *arg)
+ 	if (!selmon)
+ 		return;
+ 	if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
+-		selmon->sellt ^= 1;
++		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag] ^= 1;
+ 	if (arg && arg->v)
+-		selmon->lt[selmon->sellt] = (Layout *)arg->v;
++		selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt] = (Layout *)arg->v;
+ 	strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, LENGTH(selmon->ltsymbol));
+ 	arrange(selmon);
+ 	printstatus();
+@@ -2324,7 +2347,7 @@ setmfact(const Arg *arg)
+ 	f = arg->f < 1.0f ? arg->f + selmon->mfact : arg->f - 1.0f;
+ 	if (f < 0.1 || f > 0.9)
+ 		return;
+-	selmon->mfact = f;
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag] = f;
+ 	arrange(selmon);
+ }
+ 
+@@ -2701,9 +2724,29 @@ void
+ toggleview(const Arg *arg)
+ {
+ 	uint32_t newtagset;
++	size_t i;
+ 	if (!(newtagset = selmon ? selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK) : 0))
+ 		return;
+ 
++	if (newtagset == (uint32_t)~0) {
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++		selmon->pertag->curtag = 0;
++	}
++
++	/* test if the user did not select the same tag */
++	if (!(newtagset & 1 << (selmon->pertag->curtag - 1))) {
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++		for (i = 0; !(newtagset & 1 << i); i++) ;
++		selmon->pertag->curtag = i + 1;
++	}
++
++	/* apply settings for this view */
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
++	selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++	selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
++	selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
++
+ 	selmon->tagset[selmon->seltags] = newtagset;
+ 	focusclient(focustop(selmon), 1);
+ 	arrange(selmon);
+@@ -2892,11 +2935,33 @@ urgent(struct wl_listener *listener, void *data)
+ void
+ view(const Arg *arg)
+ {
++	size_t i, tmptag;
++
+ 	if (!selmon || (arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
+ 		return;
+ 	selmon->seltags ^= 1; /* toggle sel tagset */
+-	if (arg->ui & TAGMASK)
++	if (arg->ui & ~0) {
+ 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++
++		if (arg->ui == TAGMASK)
++			selmon->pertag->curtag = 0;
++		else {
++			for (i = 0; !(arg->ui & 1 << i); i++) ;
++			selmon->pertag->curtag = i + 1;
++		}
++	} else {
++		tmptag = selmon->pertag->prevtag;
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++		selmon->pertag->curtag = tmptag;
++	}
++
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
++	selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++	selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
++	selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
++
+ 	focusclient(focustop(selmon), 1);
+ 	arrange(selmon);
+ 	printstatus();
+-- 
+2.45.2
+

protocols/dwl-ipc-unstable-v2.xml

@@ -0,0 +1,181 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+This is largely ripped from somebar's ipc patchset; just with some personal modifications.
+I would probably just submit raphi's patchset but I don't think that would be polite.
+-->
+<protocol name="dwl_ipc_unstable_v2">
+  <description summary="inter-proccess-communication about dwl's state">
+      This protocol allows clients to update and get updates from dwl.
+
+      Warning! The protocol described in this file is experimental and
+      backward incompatible changes may be made. Backward compatible
+      changes may be added together with the corresponding interface
+      version bump.
+      Backward incompatible changes are done by bumping the version
+      number in the protocol and interface names and resetting the
+      interface version. Once the protocol is to be declared stable,
+      the 'z' prefix and the version number in the protocol and
+      interface names are removed and the interface version number is
+      reset.
+  </description>
+
+  <interface name="zdwl_ipc_manager_v2" version="2">
+    <description summary="manage dwl state">
+      This interface is exposed as a global in wl_registry.
+
+      Clients can use this interface to get a dwl_ipc_output.
+      After binding the client will recieve the dwl_ipc_manager.tags and dwl_ipc_manager.layout events.
+      The dwl_ipc_manager.tags and dwl_ipc_manager.layout events expose tags and layouts to the client.
+    </description>
+
+    <request name="release" type="destructor">
+      <description summary="release dwl_ipc_manager">
+        Indicates that the client will not the dwl_ipc_manager object anymore.
+        Objects created through this instance are not affected.
+      </description>
+    </request>
+
+    <request name="get_output">
+      <description summary="get a dwl_ipc_outout for a wl_output">
+        Get a dwl_ipc_outout for the specified wl_output.
+      </description>
+      <arg name="id" type="new_id" interface="zdwl_ipc_output_v2"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+
+    <event name="tags">
+      <description summary="Announces tag amount">
+        This event is sent after binding.
+        A roundtrip after binding guarantees the client recieved all tags.
+      </description>
+      <arg name="amount" type="uint"/>
+    </event>
+
+    <event name="layout">
+      <description summary="Announces a layout">
+        This event is sent after binding.
+        A roundtrip after binding guarantees the client recieved all layouts.
+      </description>
+      <arg name="name" type="string"/>
+    </event>
+  </interface>
+
+  <interface name="zdwl_ipc_output_v2" version="2">
+    <description summary="control dwl output">
+      Observe and control a dwl output.
+
+      Events are double-buffered:
+      Clients should cache events and redraw when a dwl_ipc_output.frame event is sent.
+
+      Request are not double-buffered:
+      The compositor will update immediately upon request.
+    </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_ipc_outout">
+        Indicates to that the client no longer needs this dwl_ipc_output.
+      </description>
+    </request>
+
+    <event name="toggle_visibility">
+      <description summary="Toggle client visibilty">
+        Indicates the client should hide or show themselves.
+        If the client is visible then hide, if hidden then show.
+      </description>
+    </event>
+
+    <event name="active">
+      <description summary="Update the selected output.">
+        Indicates if the output is active. Zero is invalid, nonzero is valid.
+      </description>
+      <arg name="active" type="uint"/>
+    </event>
+
+    <event name="tag">
+      <description summary="Update the state of a tag.">
+        Indicates that a tag has been updated.
+      </description>
+      <arg name="tag" type="uint" summary="Index of the tag"/>
+      <arg name="state" type="uint" enum="tag_state" summary="The state of the tag."/>
+      <arg name="clients" type="uint" summary="The number of clients in the tag."/>
+      <arg name="focused" type="uint" summary="If there is a focused client. Nonzero being valid, zero being invalid."/>
+    </event>
+
+    <event name="layout">
+      <description summary="Update the layout.">
+        Indicates a new layout is selected.
+      </description>
+      <arg name="layout" type="uint" summary="Index of the layout."/>
+    </event>
+
+    <event name="title">
+      <description summary="Update the title.">
+        Indicates the title has changed.
+      </description>
+      <arg name="title" type="string" summary="The new title name."/>
+    </event>
+
+    <event name="appid" since="1">
+      <description summary="Update the appid.">
+        Indicates the appid has changed.
+      </description>
+      <arg name="appid" type="string" summary="The new appid."/>
+    </event>
+
+    <event name="layout_symbol" since="1">
+      <description summary="Update the current layout symbol">
+          Indicates the layout has changed. Since layout symbols are dynamic.
+          As opposed to the zdwl_ipc_manager.layout event, this should take precendence when displaying.
+          You can ignore the zdwl_ipc_output.layout event.
+      </description>
+      <arg name="layout" type="string" summary="The new layout"/>
+    </event>
+
+    <event name="frame">
+      <description summary="The update sequence is done.">
+        Indicates that a sequence of status updates have finished and the client should redraw.
+      </description>
+    </event>
+
+    <request name="set_tags">
+      <description summary="Set the active tags of this output"/>
+      <arg name="tagmask" type="uint" summary="bitmask of the tags that should be set."/>
+      <arg name="toggle_tagset" type="uint" summary="toggle the selected tagset, zero for invalid, nonzero for valid."/>
+    </request>
+
+    <request name="set_client_tags">
+      <description summary="Set the tags of the focused client.">
+        The tags are updated as follows:
+        new_tags = (current_tags AND and_tags) XOR xor_tags
+      </description>
+      <arg name="and_tags" type="uint"/>
+      <arg name="xor_tags" type="uint"/>
+    </request>
+
+    <request name="set_layout">
+      <description summary="Set the layout of this output"/>
+      <arg name="index" type="uint" summary="index of a layout recieved by dwl_ipc_manager.layout"/>
+    </request>
+
+    <!-- Version 2 -->
+    <event name="fullscreen" since="2">
+      <description summary="Update fullscreen status">
+          Indicates if the selected client on this output is fullscreen.
+      </description>
+      <arg name="is_fullscreen" type="uint" summary="If the selected client is fullscreen. Nonzero is valid, zero invalid"/>
+    </event>
+
+    <event name="floating" since="2">
+      <description summary="Update the floating status">
+          Indicates if the selected client on this output is floating.
+      </description>
+      <arg name="is_floating" type="uint" summary="If the selected client is floating. Nonzero is valid, zero invalid"/>
+    </event>
+  </interface>
+</protocol>

protocols/wlr-foreign-toplevel-management-unstable-v1.xml

@@ -0,0 +1,270 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_foreign_toplevel_management_unstable_v1">
+  <copyright>
+    Copyright © 2018 Ilia Bozhinov
+
+    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 appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <interface name="zwlr_foreign_toplevel_manager_v1" version="3">
+    <description summary="list and control opened apps">
+      The purpose of this protocol is to enable the creation of taskbars
+      and docks by providing them with a list of opened applications and
+      letting them request certain actions on them, like maximizing, etc.
+
+      After a client binds the zwlr_foreign_toplevel_manager_v1, each opened
+      toplevel window will be sent via the toplevel event
+    </description>
+
+    <event name="toplevel">
+      <description summary="a toplevel has been created">
+        This event is emitted whenever a new toplevel window is created. It
+        is emitted for all toplevels, regardless of the app that has created
+        them.
+
+        All initial details of the toplevel(title, app_id, states, etc.) will
+        be sent immediately after this event via the corresponding events in
+        zwlr_foreign_toplevel_handle_v1.
+      </description>
+      <arg name="toplevel" type="new_id" interface="zwlr_foreign_toplevel_handle_v1"/>
+    </event>
+
+    <request name="stop">
+      <description summary="stop sending events">
+        Indicates the client no longer wishes to receive events for new toplevels.
+        However the compositor may emit further toplevel_created events, until
+        the finished event is emitted.
+
+        The client must not send any more requests after this one.
+      </description>
+    </request>
+
+    <event name="finished" type="destructor">
+      <description summary="the compositor has finished with the toplevel manager">
+        This event indicates that the compositor is done sending events to the
+        zwlr_foreign_toplevel_manager_v1. The server will destroy the object
+        immediately after sending this request, so it will become invalid and
+        the client should free any resources associated with it.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="zwlr_foreign_toplevel_handle_v1" version="3">
+    <description summary="an opened toplevel">
+      A zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel
+      window. Each app may have multiple opened toplevels.
+
+      Each toplevel has a list of outputs it is visible on, conveyed to the
+      client with the output_enter and output_leave events.
+    </description>
+
+    <event name="title">
+      <description summary="title change">
+        This event is emitted whenever the title of the toplevel changes.
+      </description>
+      <arg name="title" type="string"/>
+    </event>
+
+    <event name="app_id">
+      <description summary="app-id change">
+        This event is emitted whenever the app-id of the toplevel changes.
+      </description>
+      <arg name="app_id" type="string"/>
+    </event>
+
+    <event name="output_enter">
+      <description summary="toplevel entered an output">
+        This event is emitted whenever the toplevel becomes visible on
+        the given output. A toplevel may be visible on multiple outputs.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="output_leave">
+      <description summary="toplevel left an output">
+        This event is emitted whenever the toplevel stops being visible on
+        the given output. It is guaranteed that an entered-output event
+        with the same output has been emitted before this event.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <request name="set_maximized">
+      <description summary="requests that the toplevel be maximized">
+        Requests that the toplevel be maximized. If the maximized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="unset_maximized">
+      <description summary="requests that the toplevel be unmaximized">
+        Requests that the toplevel be unmaximized. If the maximized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="set_minimized">
+      <description summary="requests that the toplevel be minimized">
+        Requests that the toplevel be minimized. If the minimized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="unset_minimized">
+      <description summary="requests that the toplevel be unminimized">
+        Requests that the toplevel be unminimized. If the minimized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="activate">
+      <description summary="activate the toplevel">
+        Request that this toplevel be activated on the given seat.
+        There is no guarantee the toplevel will be actually activated.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat"/>
+    </request>
+
+    <enum name="state">
+      <description summary="types of states on the toplevel">
+        The different states that a toplevel can have. These have the same meaning
+        as the states with the same names defined in xdg-toplevel
+      </description>
+
+      <entry name="maximized"  value="0" summary="the toplevel is maximized"/>
+      <entry name="minimized"  value="1" summary="the toplevel is minimized"/>
+      <entry name="activated"  value="2" summary="the toplevel is active"/>
+      <entry name="fullscreen" value="3" summary="the toplevel is fullscreen" since="2"/>
+    </enum>
+
+    <event name="state">
+      <description summary="the toplevel state changed">
+        This event is emitted immediately after the zlw_foreign_toplevel_handle_v1
+        is created and each time the toplevel state changes, either because of a
+        compositor action or because of a request in this protocol.
+      </description>
+
+      <arg name="state" type="array"/>
+    </event>
+
+    <event name="done">
+      <description summary="all information about the toplevel has been sent">
+        This event is sent after all changes in the toplevel state have been
+        sent.
+
+        This allows changes to the zwlr_foreign_toplevel_handle_v1 properties
+        to be seen as atomic, even if they happen via multiple events.
+      </description>
+    </event>
+
+    <request name="close">
+      <description summary="request that the toplevel be closed">
+        Send a request to the toplevel to close itself. The compositor would
+        typically use a shell-specific method to carry out this request, for
+        example by sending the xdg_toplevel.close event. However, this gives
+        no guarantees the toplevel will actually be destroyed. If and when
+        this happens, the zwlr_foreign_toplevel_handle_v1.closed event will
+        be emitted.
+      </description>
+    </request>
+
+    <request name="set_rectangle">
+      <description summary="the rectangle which represents the toplevel">
+        The rectangle of the surface specified in this request corresponds to
+        the place where the app using this protocol represents the given toplevel.
+        It can be used by the compositor as a hint for some operations, e.g
+        minimizing. The client is however not required to set this, in which
+        case the compositor is free to decide some default value.
+
+        If the client specifies more than one rectangle, only the last one is
+        considered.
+
+        The dimensions are given in surface-local coordinates.
+        Setting width=height=0 removes the already-set rectangle.
+      </description>
+
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </request>
+
+    <enum name="error">
+      <entry name="invalid_rectangle" value="0"
+        summary="the provided rectangle is invalid"/>
+    </enum>
+
+    <event name="closed">
+      <description summary="this toplevel has been destroyed">
+        This event means the toplevel has been destroyed. It is guaranteed there
+        won't be any more events for this zwlr_foreign_toplevel_handle_v1. The
+        toplevel itself becomes inert so any requests will be ignored except the
+        destroy request.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the zwlr_foreign_toplevel_handle_v1 object">
+        Destroys the zwlr_foreign_toplevel_handle_v1 object.
+
+        This request should be called either when the client does not want to
+        use the toplevel anymore or after the closed event to finalize the
+        destruction of the object.
+      </description>
+    </request>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_fullscreen" since="2">
+      <description summary="request that the toplevel be fullscreened">
+        Requests that the toplevel be fullscreened on the given output. If the
+        fullscreen state and/or the outputs the toplevel is visible on actually
+        change, this will be indicated by the state and output_enter/leave
+        events.
+
+        The output parameter is only a hint to the compositor. Also, if output
+        is NULL, the compositor should decide which output the toplevel will be
+        fullscreened on, if at all.
+      </description>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+    </request>
+
+    <request name="unset_fullscreen" since="2">
+      <description summary="request that the toplevel be unfullscreened">
+        Requests that the toplevel be unfullscreened. If the fullscreen state
+        actually changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <!-- Version 3 additions -->
+
+    <event name="parent" since="3">
+      <description summary="parent change">
+        This event is emitted whenever the parent of the toplevel changes.
+
+        No event is emitted when the parent handle is destroyed by the client.
+      </description>
+      <arg name="parent" type="object" interface="zwlr_foreign_toplevel_handle_v1" allow-null="true"/>
+    </event>
+  </interface>
+</protocol>

swallow.patch

@@ -0,0 +1,351 @@
+From a220e1ed4b04a66c837dfc8e3363d3e696cbf541 Mon Sep 17 00:00:00 2001
+From: Nikita Ivanov <nikita.vyach.ivanov@gmail.com>
+Date: Wed, 5 Feb 2025 02:34:39 +0100
+Subject: [PATCH] Swallow: hide the terminal when it spawns a client
+
+---
+ client.h     |  12 ++++
+ config.def.h |  11 +++-
+ dwl.c        | 152 +++++++++++++++++++++++++++++++++++++++++++++++++--
+ 3 files changed, 168 insertions(+), 7 deletions(-)
+
+diff --git a/client.h b/client.h
+index 42f225f..bc9cad2 100644
+--- a/client.h
++++ b/client.h
+@@ -131,6 +131,18 @@ client_get_appid(Client *c)
+ 	return c->surface.xdg->toplevel->app_id;
+ }
+ 
++static inline int
++client_get_pid(Client *c)
++{
++	pid_t pid;
++#ifdef XWAYLAND
++	if (client_is_x11(c))
++		return c->surface.xwayland->pid;
++#endif
++	wl_client_get_credentials(c->surface.xdg->client->client, &pid, NULL, NULL);
++	return pid;
++}
++
+ static inline void
+ client_get_clip(Client *c, struct wlr_box *clip)
+ {
+diff --git a/config.def.h b/config.def.h
+index 22d2171..42342f1 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -13,6 +13,8 @@ static const float focuscolor[]            = COLOR(0x005577ff);
+ static const float urgentcolor[]           = COLOR(0xff0000ff);
+ /* This conforms to the xdg-protocol. Set the alpha to zero to restore the old behavior */
+ static const float fullscreen_bg[]         = {0.1f, 0.1f, 0.1f, 1.0f}; /* You can also use glsl colors */
++static int enableautoswallow = 1; /* enables autoswallowing newly spawned clients */
++static float swallowborder = 1.0f; /* add this multiplied by borderpx to border when a client is swallowed */
+ 
+ /* tagging - TAGCOUNT must be no greater than 31 */
+ #define TAGCOUNT (9)
+@@ -22,10 +24,11 @@ static int log_level = WLR_ERROR;
+ 
+ /* NOTE: ALWAYS keep a rule declared even if you don't use rules (e.g leave at least one example) */
+ static const Rule rules[] = {
+-	/* app_id             title       tags mask     isfloating   monitor */
++	/* app_id             title       tags mask     isfloating   isterm   noswallow   monitor */
+ 	/* examples: */
+-	{ "Gimp_EXAMPLE",     NULL,       0,            1,           -1 }, /* Start on currently visible tags floating, not tiled */
+-	{ "firefox_EXAMPLE",  NULL,       1 << 8,       0,           -1 }, /* Start on ONLY tag "9" */
++	{ "foot",             NULL,       0,            0,           1,       1,          -1 },
++	{ "Gimp_EXAMPLE",     NULL,       0,            1,           0,       0,          -1 }, /* Start on currently visible tags floating, not tiled */
++	{ "firefox_EXAMPLE",  NULL,       1 << 8,       0,           0,       0,          -1 }, /* Start on ONLY tag "9" */
+ };
+ 
+ /* layout(s) */
+@@ -142,6 +145,8 @@ static const Key keys[] = {
+ 	{ MODKEY,                    XKB_KEY_space,      setlayout,      {0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_space,      togglefloating, {0} },
+ 	{ MODKEY,                    XKB_KEY_e,         togglefullscreen, {0} },
++	{ MODKEY,                    XKB_KEY_a,          toggleswallow,  {0} },
++	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_A,          toggleautoswallow,{0} },
+ 	{ MODKEY,                    XKB_KEY_0,          view,           {.ui = ~0} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_parenright, tag,            {.ui = ~0} },
+ 	{ MODKEY,                    XKB_KEY_comma,      focusmon,       {.i = WLR_DIRECTION_LEFT} },
+diff --git a/dwl.c b/dwl.c
+index def2562..71d500a 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -73,12 +73,13 @@
+ #define MAX(A, B)               ((A) > (B) ? (A) : (B))
+ #define MIN(A, B)               ((A) < (B) ? (A) : (B))
+ #define CLEANMASK(mask)         (mask & ~WLR_MODIFIER_CAPS)
+-#define VISIBLEON(C, M)         ((M) && (C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags]))
++#define VISIBLEON(C, M)         ((M) && (C)->mon == (M) && ((C)->tags & (M)->tagset[(M)->seltags]) && !(C)->swallowedby)
+ #define LENGTH(X)               (sizeof X / sizeof X[0])
+ #define END(A)                  ((A) + LENGTH(A))
+ #define TAGMASK                 ((1u << TAGCOUNT) - 1)
+ #define LISTEN(E, L, H)         wl_signal_add((E), ((L)->notify = (H), (L)))
+ #define LISTEN_STATIC(E, H)     do { static struct wl_listener _l = {.notify = (H)}; wl_signal_add((E), &_l); } while (0)
++#define BORDERPX(C)             (borderpx + ((C)->swallowing ? (int)ceilf(swallowborder * (C)->swallowing->bw) : 0))
+ 
+ /* enums */
+ enum { CurNormal, CurPressed, CurMove, CurResize }; /* cursor */
+@@ -104,7 +105,8 @@ typedef struct {
+ } Button;
+ 
+ typedef struct Monitor Monitor;
+-typedef struct {
++typedef struct Client Client;
++struct Client {
+ 	/* Must keep these three elements in this order */
+ 	unsigned int type; /* XDGShell or X11* */
+ 	struct wlr_box geom; /* layout-relative, includes border */
+@@ -140,8 +142,12 @@ typedef struct {
+ 	unsigned int bw;
+ 	uint32_t tags;
+ 	int isfloating, isurgent, isfullscreen;
++	int isterm, noswallow;
+ 	uint32_t resize; /* configure serial of a pending resize */
+-} Client;
++	pid_t pid;
++	Client *swallowing;  /* client being hidden */
++	Client *swallowedby;
++};
+ 
+ typedef struct {
+ 	uint32_t mod;
+@@ -230,6 +236,8 @@ typedef struct {
+ 	const char *title;
+ 	uint32_t tags;
+ 	int isfloating;
++	int isterm;
++	int noswallow;
+ 	int monitor;
+ } Rule;
+ 
+@@ -311,6 +319,7 @@ static void moveresize(const Arg *arg);
+ static void outputmgrapply(struct wl_listener *listener, void *data);
+ static void outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test);
+ static void outputmgrtest(struct wl_listener *listener, void *data);
++static pid_t parentpid(pid_t pid);
+ static void pointerfocus(Client *c, struct wlr_surface *surface,
+ 		double sx, double sy, uint32_t time);
+ static void printstatus(void);
+@@ -335,11 +344,15 @@ static void setsel(struct wl_listener *listener, void *data);
+ static void setup(void);
+ static void spawn(const Arg *arg);
+ static void startdrag(struct wl_listener *listener, void *data);
++static void swallow(Client *c, Client *toswallow);
+ static void tag(const Arg *arg);
+ static void tagmon(const Arg *arg);
++static Client *termforwin(Client *c);
+ static void tile(Monitor *m);
+ static void togglefloating(const Arg *arg);
+ static void togglefullscreen(const Arg *arg);
++static void toggleswallow(const Arg *arg);
++static void toggleautoswallow(const Arg *arg);
+ static void toggletag(const Arg *arg);
+ static void toggleview(const Arg *arg);
+ static void unlocksession(struct wl_listener *listener, void *data);
+@@ -466,11 +479,15 @@ applyrules(Client *c)
+ 	if (!(title = client_get_title(c)))
+ 		title = broken;
+ 
++	c->pid = client_get_pid(c);
++
+ 	for (r = rules; r < END(rules); r++) {
+ 		if ((!r->title || strstr(title, r->title))
+ 				&& (!r->id || strstr(appid, r->id))) {
+ 			c->isfloating = r->isfloating;
+ 			newtags |= r->tags;
++			c->isterm = r->isterm;
++			c->noswallow = r->noswallow;
+ 			i = 0;
+ 			wl_list_for_each(m, &mons, link) {
+ 				if (r->monitor == i++)
+@@ -478,6 +495,12 @@ applyrules(Client *c)
+ 			}
+ 		}
+ 	}
++	if (enableautoswallow && !c->noswallow && !c->isfloating &&
++			!c->surface.xdg->initial_commit) {
++		Client *p = termforwin(c);
++		if (p)
++			swallow(c, p);
++	}
+ 	setmon(c, mon, newtags);
+ }
+ 
+@@ -2006,6 +2029,20 @@ outputmgrtest(struct wl_listener *listener, void *data)
+ 	outputmgrapplyortest(config, 1);
+ }
+ 
++pid_t
++parentpid(pid_t pid)
++{
++	unsigned int v = 0;
++	FILE *f;
++	char buf[256];
++	snprintf(buf, sizeof(buf) - 1, "/proc/%u/stat", (unsigned)pid);
++	if (!(f = fopen(buf, "r")))
++		return 0;
++	fscanf(f, "%*u %*s %*c %u", &v);
++	fclose(f);
++	return (pid_t)v;
++}
++
+ void
+ pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
+ 		uint32_t time)
+@@ -2326,7 +2363,7 @@ setfullscreen(Client *c, int fullscreen)
+ 	c->isfullscreen = fullscreen;
+ 	if (!c->mon || !client_surface(c)->mapped)
+ 		return;
+-	c->bw = fullscreen ? 0 : borderpx;
++	c->bw = fullscreen ? 0 : BORDERPX(c);
+ 	client_set_fullscreen(c, fullscreen);
+ 	wlr_scene_node_reparent(&c->scene->node, layers[c->isfullscreen
+ 			? LyrFS : c->isfloating ? LyrFloat : LyrTile]);
+@@ -2404,6 +2441,9 @@ setmon(Client *c, Monitor *m, uint32_t newtags)
+ 		setfloating(c, c->isfloating);
+ 	}
+ 	focusclient(focustop(selmon), 1);
++
++	if (c->swallowing)
++		setmon(c->swallowing, m, newtags);
+ }
+ 
+ void
+@@ -2669,6 +2709,44 @@ startdrag(struct wl_listener *listener, void *data)
+ 	LISTEN_STATIC(&drag->icon->events.destroy, destroydragicon);
+ }
+ 
++void
++swallow(Client *c, Client *toswallow)
++{
++	/* Do not allow a client to swallow itself */
++	if (c == toswallow)
++		return;
++
++	/* Swallow */
++	if (toswallow && !c->swallowing) {
++		c->swallowing = toswallow;
++		toswallow->swallowedby = c;
++		toswallow->mon = c->mon;
++		toswallow->mon = c->mon;
++		wl_list_remove(&c->link);
++		wl_list_insert(&c->swallowing->link, &c->link);
++		wl_list_remove(&c->flink);
++		wl_list_insert(&c->swallowing->flink, &c->flink);
++		c->bw = BORDERPX(c);
++		c->tags = toswallow->tags;
++		c->isfloating = toswallow->isfloating;
++		c->geom = toswallow->geom;
++		setfullscreen(toswallow, 0);
++	}
++
++	/* Unswallow */
++	else if (c->swallowing) {
++		wl_list_remove(&c->swallowing->link);
++		wl_list_insert(&c->link, &c->swallowing->link);
++		wl_list_remove(&c->swallowing->flink);
++		wl_list_insert(&c->flink, &c->swallowing->flink);
++		c->swallowing->tags = c->tags;
++		c->swallowing->swallowedby = NULL;
++		c->swallowing = NULL;
++		c->bw = BORDERPX(c);
++		setfullscreen(c, 0);
++	}
++}
++
+ void
+ tag(const Arg *arg)
+ {
+@@ -2690,6 +2768,40 @@ tagmon(const Arg *arg)
+ 		setmon(sel, dirtomon(arg->i), 0);
+ }
+ 
++Client *
++termforwin(Client *c)
++{
++	Client *p;
++	pid_t pid;
++	pid_t pids[32];
++	size_t i, pids_len;
++
++	if (!c->pid || c->isterm)
++		return NULL;
++
++	/* Get all parent pids */
++	pids_len = 0;
++	pid = c->pid;
++	while (pids_len < LENGTH(pids)) {
++		pid = parentpid(pid);
++		if (!pid)
++			break;
++		pids[pids_len++] = pid;
++	}
++
++	/* Find closest parent */
++	for (i = 0; i < pids_len; i++) {
++		wl_list_for_each(p, &clients, link) {
++			if (!p->pid || !p->isterm || p->swallowedby)
++				continue;
++			if (pids[i] == p->pid)
++				return p;
++		}
++	}
++
++	return NULL;
++}
++
+ void
+ tile(Monitor *m)
+ {
+@@ -2741,6 +2853,32 @@ togglefullscreen(const Arg *arg)
+ 		setfullscreen(sel, !sel->isfullscreen);
+ }
+ 
++void
++toggleswallow(const Arg *arg)
++{
++	Client *c, *sel = focustop(selmon);
++	if (!sel)
++		return;
++
++	if (sel->swallowing) {
++		swallow(sel, NULL);
++	} else {
++		wl_list_for_each(c, &sel->flink, flink) {
++			if (&c->flink == &fstack)
++				continue; /* wrap past the sentinel node */
++			if (VISIBLEON(c, selmon))
++				break; /* found it */
++		}
++		swallow(sel, c);
++	}
++}
++
++void
++toggleautoswallow(const Arg *arg)
++{
++	enableautoswallow = !enableautoswallow;
++}
++
+ void
+ toggletag(const Arg *arg)
+ {
+@@ -2801,6 +2939,12 @@ unmapnotify(struct wl_listener *listener, void *data)
+ 		grabc = NULL;
+ 	}
+ 
++	if (c->swallowing) {
++		swallow(c, NULL);
++	} else if (c->swallowedby) {
++		swallow(c->swallowedby, NULL);
++	}
++
+ 	if (client_is_unmanaged(c)) {
+ 		if (c == exclusive_focus) {
+ 			exclusive_focus = NULL;
+-- 
+2.49.0
+

togglekblayoutandoptions.patch

@@ -0,0 +1,160 @@
+From 9ee76adc7c6567650e7b34273f953fed03191c05 Mon Sep 17 00:00:00 2001
+From: LaKato <lakato@noreply.codeberg.org>
+Date: Sat, 8 Mar 2025 12:14:41 -0500
+Subject: [PATCH] Update for v0.7
+
+Additional changes:
+- incxkbrules now uses its argument
+- A new setxkbrules function has been added
+- Keyboard groups are no longer looped over because only one is created
+---
+ config.def.h | 17 +++++++++++------
+ dwl.c        | 44 +++++++++++++++++++++++++++++++++-----------
+ 2 files changed, 44 insertions(+), 17 deletions(-)
+
+diff --git a/config.def.h b/config.def.h
+index 22d2171..b3b4699 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -52,12 +52,15 @@ static const MonitorRule monrules[] = {
+ };
+ 
+ /* keyboard */
+-static const struct xkb_rule_names xkb_rules = {
+-	/* can specify fields: rules, model, layout, variant, options */
+-	/* example:
+-	.options = "ctrl:nocaps",
+-	*/
+-	.options = NULL,
++static const struct xkb_rule_names xkb_rules[] = {
++	{
++		.layout = "us",
++	},
++	/*{
++		.layout = "us",
++		.variant = "dvp",
++		.options = "compose:102,numpad:shift3,kpdl:semi,keypad:atm,caps:super"
++	}*/
+ };
+ 
+ static const int repeat_rate = 25;
+@@ -148,6 +151,8 @@ static const Key keys[] = {
+ 	{ MODKEY,                    XKB_KEY_period,     focusmon,       {.i = WLR_DIRECTION_RIGHT} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_less,       tagmon,         {.i = WLR_DIRECTION_LEFT} },
+ 	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_greater,    tagmon,         {.i = WLR_DIRECTION_RIGHT} },
++	{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_A,          incxkbrules,    {.i = +1} },
++	/*{ MODKEY|WLR_MODIFIER_SHIFT, XKB_KEY_E,          setxkbrules,    {.i = +1} },*/
+ 	TAGKEYS(          XKB_KEY_1, XKB_KEY_exclam,                     0),
+ 	TAGKEYS(          XKB_KEY_2, XKB_KEY_at,                         1),
+ 	TAGKEYS(          XKB_KEY_3, XKB_KEY_numbersign,                 2),
+diff --git a/dwl.c b/dwl.c
+index a2711f6..a2413e9 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -249,6 +249,7 @@ static void arrange(Monitor *m);
+ static void arrangelayer(Monitor *m, struct wl_list *list,
+ 		struct wlr_box *usable_area, int exclusive);
+ static void arrangelayers(Monitor *m);
++static void assignkeymap(struct wlr_keyboard *keyboard);
+ static void axisnotify(struct wl_listener *listener, void *data);
+ static void buttonpress(struct wl_listener *listener, void *data);
+ static void chvt(const Arg *arg);
+@@ -293,6 +294,7 @@ static void fullscreennotify(struct wl_listener *listener, void *data);
+ static void gpureset(struct wl_listener *listener, void *data);
+ static void handlesig(int signo);
+ static void incnmaster(const Arg *arg);
++static void incxkbrules(const Arg *arg);
+ static void inputdevice(struct wl_listener *listener, void *data);
+ static int keybinding(uint32_t mods, xkb_keysym_t sym);
+ static void keypress(struct wl_listener *listener, void *data);
+@@ -333,6 +335,7 @@ static void setmon(Client *c, Monitor *m, uint32_t newtags);
+ static void setpsel(struct wl_listener *listener, void *data);
+ static void setsel(struct wl_listener *listener, void *data);
+ static void setup(void);
++static void setxkbrules(const Arg *arg);
+ static void spawn(const Arg *arg);
+ static void startdrag(struct wl_listener *listener, void *data);
+ static void tag(const Arg *arg);
+@@ -404,6 +407,7 @@ static struct wl_listener lock_listener = {.notify = locksession};
+ 
+ static struct wlr_seat *seat;
+ static KeyboardGroup *kb_group;
++static unsigned int kblayout = 0;
+ static unsigned int cursor_mode;
+ static Client *grabc;
+ static int grabcx, grabcy; /* client-relative */
+@@ -580,6 +584,20 @@ arrangelayers(Monitor *m)
+ 	}
+ }
+ 
++void
++assignkeymap(struct wlr_keyboard *keyboard) {
++	struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
++	struct xkb_keymap *keymap = xkb_keymap_new_from_names(context, &xkb_rules[kblayout],
++					XKB_KEYMAP_COMPILE_NO_FLAGS);
++
++	if (!keymap)
++		die("failed to compile keymap");
++
++	wlr_keyboard_set_keymap(keyboard, keymap);
++	xkb_keymap_unref(keymap);
++	xkb_context_unref(context);
++}
++
+ void
+ axisnotify(struct wl_listener *listener, void *data)
+ {
+@@ -885,21 +903,11 @@ KeyboardGroup *
+ createkeyboardgroup(void)
+ {
+ 	KeyboardGroup *group = ecalloc(1, sizeof(*group));
+-	struct xkb_context *context;
+-	struct xkb_keymap *keymap;
+ 
+ 	group->wlr_group = wlr_keyboard_group_create();
+ 	group->wlr_group->data = group;
+ 
+-	/* Prepare an XKB keymap and assign it to the keyboard group. */
+-	context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+-	if (!(keymap = xkb_keymap_new_from_names(context, &xkb_rules,
+-				XKB_KEYMAP_COMPILE_NO_FLAGS)))
+-		die("failed to compile keymap");
+-
+-	wlr_keyboard_set_keymap(&group->wlr_group->keyboard, keymap);
+-	xkb_keymap_unref(keymap);
+-	xkb_context_unref(context);
++	assignkeymap(&group->wlr_group->keyboard);
+ 
+ 	wlr_keyboard_set_repeat_info(&group->wlr_group->keyboard, repeat_rate, repeat_delay);
+ 
+@@ -1524,6 +1532,13 @@ incnmaster(const Arg *arg)
+ 	arrange(selmon);
+ }
+ 
++void
++incxkbrules(const Arg *arg)
++{
++	kblayout = (kblayout + arg->i) % LENGTH(xkb_rules);
++	assignkeymap(&kb_group->wlr_group->keyboard);
++}
++
+ void
+ inputdevice(struct wl_listener *listener, void *data)
+ {
+@@ -2645,6 +2660,13 @@ setup(void)
+ #endif
+ }
+ 
++void
++setxkbrules(const Arg *arg)
++{
++	kblayout = arg->i;
++	assignkeymap(&kb_group->wlr_group->keyboard);
++}
++
+ void
+ spawn(const Arg *arg)
+ {
+-- 
+2.48.1
+

unclutter.patch

@@ -0,0 +1,188 @@
+From 52d5a05a6b4ca9555c072e103c2db454d2b35021 Mon Sep 17 00:00:00 2001
+From: Guido Cella <guido@guidocella.xyz>
+Date: Thu, 25 Jul 2024 17:59:05 +0200
+Subject: [PATCH] =?UTF-8?q?hide=20the=20mouse=20cursor=20if=20it=20isn?=
+ =?UTF-8?q?=E2=80=99t=20being=20used?=
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+---
+ config.def.h |  2 ++
+ dwl.c        | 70 ++++++++++++++++++++++++++++++++++++++++++++++------
+ 2 files changed, 65 insertions(+), 7 deletions(-)
+
+diff --git a/config.def.h b/config.def.h
+index 22d2171..790c73d 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -106,6 +106,8 @@ LIBINPUT_CONFIG_TAP_MAP_LMR -- 1/2/3 finger tap maps to left/middle/right
+ */
+ static const enum libinput_config_tap_button_map button_map = LIBINPUT_CONFIG_TAP_MAP_LRM;
+ 
++static const int cursor_timeout = 5;
++
+ /* If you want to use the windows key for MODKEY, use WLR_MODIFIER_LOGO */
+ #define MODKEY WLR_MODIFIER_ALT
+ 
+diff --git a/dwl.c b/dwl.c
+index 72892d9..4090d73 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -292,6 +292,8 @@ static void focusstack(const Arg *arg);
+ static Client *focustop(Monitor *m);
+ static void fullscreennotify(struct wl_listener *listener, void *data);
+ static void gpureset(struct wl_listener *listener, void *data);
++static void handlecursoractivity(void);
++static int hidecursor(void *data);
+ static void handlesig(int signo);
+ static void incnmaster(const Arg *arg);
+ static void inputdevice(struct wl_listener *listener, void *data);
+@@ -396,6 +398,14 @@ static struct wlr_pointer_constraint_v1 *active_constraint;
+ 
+ static struct wlr_cursor *cursor;
+ static struct wlr_xcursor_manager *cursor_mgr;
++static struct wl_event_source *hide_source;
++static bool cursor_hidden = false;
++static struct {
++	enum wp_cursor_shape_device_v1_shape shape;
++	struct wlr_surface *surface;
++	int hotspot_x;
++	int hotspot_y;
++} last_cursor;
+ 
+ static struct wlr_scene_rect *root_bg;
+ static struct wlr_session_lock_manager_v1 *session_lock_mgr;
+@@ -588,6 +598,7 @@ axisnotify(struct wl_listener *listener, void *data)
+ 	 * for example when you move the scroll wheel. */
+ 	struct wlr_pointer_axis_event *event = data;
+ 	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
++	handlecursoractivity();
+ 	/* TODO: allow usage of scroll whell for mousebindings, it can be implemented
+ 	 * checking the event's orientation and the delta of the event */
+ 	/* Notify the client with pointer focus of the axis event. */
+@@ -606,6 +617,7 @@ buttonpress(struct wl_listener *listener, void *data)
+ 	const Button *b;
+ 
+ 	wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
++	handlecursoractivity();
+ 
+ 	switch (event->state) {
+ 	case WL_POINTER_BUTTON_STATE_PRESSED:
+@@ -1517,6 +1529,32 @@ handlesig(int signo)
+ 	}
+ }
+ 
++void
++handlecursoractivity(void)
++{
++	wl_event_source_timer_update(hide_source, cursor_timeout * 1000);
++
++	if (!cursor_hidden)
++		return;
++
++	cursor_hidden = false;
++
++	if (last_cursor.shape)
++		wlr_cursor_set_xcursor(cursor, cursor_mgr,
++				wlr_cursor_shape_v1_name(last_cursor.shape));
++	else
++		wlr_cursor_set_surface(cursor, last_cursor.surface,
++				last_cursor.hotspot_x, last_cursor.hotspot_y);
++}
++
++int
++hidecursor(void *data)
++{
++	wlr_cursor_unset_image(cursor);
++	cursor_hidden = true;
++	return 1;
++}
++
+ void
+ incnmaster(const Arg *arg)
+ {
+@@ -1856,6 +1894,7 @@ motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double d
+ 
+ 		wlr_cursor_move(cursor, device, dx, dy);
+ 		wlr_idle_notifier_v1_notify_activity(idle_notifier, seat);
++		handlecursoractivity();
+ 
+ 		/* Update selmon (even while dragging a window) */
+ 		if (sloppyfocus)
+@@ -1880,7 +1919,7 @@ motionnotify(uint32_t time, struct wlr_input_device *device, double dx, double d
+ 	/* If there's no client surface under the cursor, set the cursor image to a
+ 	 * default. This is what makes the cursor image appear when you move it
+ 	 * off of a client or over its border. */
+-	if (!surface && !seat->drag)
++	if (!surface && !seat->drag && !cursor_hidden)
+ 		wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
+ 
+ 	pointerfocus(c, surface, sx, sy, time);
+@@ -2263,6 +2302,7 @@ run(char *startup_cmd)
+ 	 * monitor when displayed here */
+ 	wlr_cursor_warp_closest(cursor, NULL, cursor->x, cursor->y);
+ 	wlr_cursor_set_xcursor(cursor, cursor_mgr, "default");
++	handlecursoractivity();
+ 
+ 	/* Run the Wayland event loop. This does not return until you exit the
+ 	 * compositor. Starting the backend rigged up all of the necessary event
+@@ -2286,9 +2326,16 @@ setcursor(struct wl_listener *listener, void *data)
+ 	 * use the provided surface as the cursor image. It will set the
+ 	 * hardware cursor on the output that it's currently on and continue to
+ 	 * do so as the cursor moves between outputs. */
+-	if (event->seat_client == seat->pointer_state.focused_client)
+-		wlr_cursor_set_surface(cursor, event->surface,
+-				event->hotspot_x, event->hotspot_y);
++	if (event->seat_client == seat->pointer_state.focused_client) {
++		last_cursor.shape = 0;
++		last_cursor.surface = event->surface;
++		last_cursor.hotspot_x = event->hotspot_x;
++		last_cursor.hotspot_y = event->hotspot_y;
++
++		if (!cursor_hidden)
++			wlr_cursor_set_surface(cursor, event->surface,
++					event->hotspot_x, event->hotspot_y);
++	}
+ }
+ 
+ void
+@@ -2300,9 +2347,14 @@ setcursorshape(struct wl_listener *listener, void *data)
+ 	/* This can be sent by any client, so we check to make sure this one is
+ 	 * actually has pointer focus first. If so, we can tell the cursor to
+ 	 * use the provided cursor shape. */
+-	if (event->seat_client == seat->pointer_state.focused_client)
+-		wlr_cursor_set_xcursor(cursor, cursor_mgr,
+-				wlr_cursor_shape_v1_name(event->shape));
++	if (event->seat_client == seat->pointer_state.focused_client) {
++		last_cursor.shape = event->shape;
++		last_cursor.surface = NULL;
++
++		if (!cursor_hidden)
++			wlr_cursor_set_xcursor(cursor, cursor_mgr,
++					wlr_cursor_shape_v1_name(event->shape));
++	}
+ }
+ 
+ void
+@@ -2604,6 +2656,9 @@ setup(void)
+ 	cursor_shape_mgr = wlr_cursor_shape_manager_v1_create(dpy, 1);
+ 	LISTEN_STATIC(&cursor_shape_mgr->events.request_set_shape, setcursorshape);
+ 
++	hide_source = wl_event_loop_add_timer(wl_display_get_event_loop(dpy),
++			hidecursor, cursor);
++
+ 	/*
+ 	 * Configures a seat, which is a single "seat" at which a user sits and
+ 	 * operates the computer. This conceptually includes up to one keyboard,
+@@ -2986,6 +3041,7 @@ virtualpointer(struct wl_listener *listener, void *data)
+ 	wlr_cursor_attach_input_device(cursor, device);
+ 	if (event->suggested_output)
+ 		wlr_cursor_map_input_to_output(cursor, device, event->suggested_output);
++	handlecursoractivity();
+ }
+ 
+ Monitor *
+-- 
+2.45.2
+

warpcursor.patch

@@ -0,0 +1,71 @@
+From 4951ccc89dac2b557994b2f6c3aacb2398e2d1b1 Mon Sep 17 00:00:00 2001
+From: Ben Collerson <benc@benc.cc>
+Date: Thu, 4 Jan 2024 20:30:01 +1000
+Subject: [PATCH] warpcursor
+
+---
+ dwl.c | 27 +++++++++++++++++++++++++++
+ 1 file changed, 27 insertions(+)
+
+diff --git a/dwl.c b/dwl.c
+index 145fd018..f7ad6c13 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -347,6 +347,7 @@ static void urgent(struct wl_listener *listener, void *data);
+ static void view(const Arg *arg);
+ static void virtualkeyboard(struct wl_listener *listener, void *data);
+ static void virtualpointer(struct wl_listener *listener, void *data);
++static void warpcursor(const Client *c);
+ static Monitor *xytomon(double x, double y);
+ static void xytonode(double x, double y, struct wlr_surface **psurface,
+ 		Client **pc, LayerSurface **pl, double *nx, double *ny);
+@@ -514,6 +515,7 @@ arrange(Monitor *m)
+ 		m->lt[m->sellt]->arrange(m);
+ 	motionnotify(0, NULL, 0, 0, 0, 0);
+ 	checkidleinhibitor(NULL);
++	warpcursor(focustop(selmon));
+ }
+ 
+ void
+@@ -1323,6 +1325,10 @@ focusclient(Client *c, int lift)
+ 	if (locked)
+ 		return;
+ 
++	/* Warp cursor to center of client if it is outside */
++	if (lift)
++		warpcursor(c);
++
+ 	/* Raise client in stacking order if requested */
+ 	if (c && lift)
+ 		wlr_scene_node_raise_to_top(&c->scene->node);
+@@ -2927,6 +2933,27 @@ virtualpointer(struct wl_listener *listener, void *data)
+ 		wlr_cursor_map_input_to_output(cursor, &pointer.base, event->suggested_output);
+ }
+ 
++void
++warpcursor(const Client *c) {
++	if (cursor_mode != CurNormal) {
++		return;
++	}
++	if (!c && selmon) {
++		wlr_cursor_warp_closest(cursor,
++			  NULL,
++			  selmon->w.x + selmon->w.width / 2.0 ,
++			  selmon->w.y + selmon->w.height / 2.0);
++	}
++	else if ( c && (cursor->x < c->geom.x ||
++		cursor->x > c->geom.x + c->geom.width ||
++		cursor->y < c->geom.y ||
++		cursor->y > c->geom.y + c->geom.height))
++		wlr_cursor_warp_closest(cursor,
++			  NULL,
++			  c->geom.x + c->geom.width / 2.0,
++			  c->geom.y + c->geom.height / 2.0);
++}
++
+ Monitor *
+ xytomon(double x, double y)
+ {
+-- 
+2.45.2
+

xwayland-handle-minimize.patch

@@ -0,0 +1,91 @@
+From 7277f668f19f5a7fcfbbc96e80cb2829487848ca Mon Sep 17 00:00:00 2001
+From: korei999 <ju7t1xe@gmail.com>
+Date: Mon, 1 Apr 2024 15:13:11 +0300
+Subject: [PATCH] handle minimize request for xwayland clients
+
+---
+ client.h |  9 ++++++---
+ dwl.c    | 19 +++++++++++++++++++
+ 2 files changed, 25 insertions(+), 3 deletions(-)
+
+diff --git a/client.h b/client.h
+index 800b867..c46cfb2 100644
+--- a/client.h
++++ b/client.h
+@@ -94,9 +94,12 @@ client_activate_surface(struct wlr_surface *s, int activated)
+ {
+ 	struct wlr_xdg_toplevel *toplevel;
+ #ifdef XWAYLAND
+-	struct wlr_xwayland_surface *xsurface;
+-	if ((xsurface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
+-		wlr_xwayland_surface_activate(xsurface, activated);
++	struct wlr_xwayland_surface *surface;
++	if ((surface = wlr_xwayland_surface_try_from_wlr_surface(s))) {
++		if (activated && surface->minimized)
++			wlr_xwayland_surface_set_minimized(surface, false);
++
++		wlr_xwayland_surface_activate(surface, activated);
+ 		return;
+ 	}
+ #endif
+diff --git a/dwl.c b/dwl.c
+index 39ce68c..b49f57b 100644
+--- a/dwl.c
++++ b/dwl.c
+@@ -131,6 +131,7 @@ typedef struct {
+ #ifdef XWAYLAND
+ 	struct wl_listener activate;
+ 	struct wl_listener associate;
++	struct wl_listener minimize;
+ 	struct wl_listener dissociate;
+ 	struct wl_listener configure;
+ 	struct wl_listener set_hints;
+@@ -412,6 +413,7 @@ static void configurex11(struct wl_listener *listener, void *data);
+ static void createnotifyx11(struct wl_listener *listener, void *data);
+ static void dissociatex11(struct wl_listener *listener, void *data);
+ static xcb_atom_t getatom(xcb_connection_t *xc, const char *name);
++static void minimizenotify(struct wl_listener *listener, void *data);
+ static void sethints(struct wl_listener *listener, void *data);
+ static void xwaylandready(struct wl_listener *listener, void *data);
+ static struct wlr_xwayland *xwayland;
+@@ -1177,6 +1179,7 @@ destroynotify(struct wl_listener *listener, void *data)
+ 		wl_list_remove(&c->activate.link);
+ 		wl_list_remove(&c->associate.link);
+ 		wl_list_remove(&c->configure.link);
++		wl_list_remove(&c->minimize.link);
+ 		wl_list_remove(&c->dissociate.link);
+ 		wl_list_remove(&c->set_hints.link);
+ 	} else
+@@ -2984,6 +2987,7 @@ createnotifyx11(struct wl_listener *listener, void *data)
+ 	LISTEN(&xsurface->events.destroy, &c->destroy, destroynotify);
+ 	LISTEN(&xsurface->events.dissociate, &c->dissociate, dissociatex11);
+ 	LISTEN(&xsurface->events.request_activate, &c->activate, activatex11);
++	LISTEN(&xsurface->events.request_minimize, &c->minimize, minimizenotify);
+ 	LISTEN(&xsurface->events.request_configure, &c->configure, configurex11);
+ 	LISTEN(&xsurface->events.request_fullscreen, &c->fullscreen, fullscreennotify);
+ 	LISTEN(&xsurface->events.set_hints, &c->set_hints, sethints);
+@@ -3011,6 +3015,21 @@ getatom(xcb_connection_t *xc, const char *name)
+ 	return atom;
+ }
+ 
++void
++minimizenotify(struct wl_listener *listener, void *data)
++{
++	Client *c = wl_container_of(listener, c, minimize);
++	struct wlr_xwayland_surface *xsurface = c->surface.xwayland;
++	struct wlr_xwayland_minimize_event *e = data;
++	int focused;
++
++	if (xsurface->surface == NULL || !xsurface->surface->mapped)
++		return;
++
++	focused = seat->keyboard_state.focused_surface == xsurface->surface;
++	wlr_xwayland_surface_set_minimized(xsurface, !focused && e->minimize);
++}
++
+ void
+ sethints(struct wl_listener *listener, void *data)
+ {
+-- 
+2.44.0
+