bacalhau/suckless
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
suckless/dwm/dwm-dynamicswallow-20240320-061e9fe.diff
bacalhau d8a9fcbc98 first commit
2025-07-02 15:45:16 +01:00

1020 lines
29 KiB
Diff
Executable file
Raw Blame History

From 20175007156c243ee577e0aa518a05282950e766 Mon Sep 17 00:00:00 2001
From: visil <workregor@mail.ru>
Date: Wed, 20 Mar 2024 17:48:47 +0300
Subject: [PATCH] Dynamic swallowing patch for 6.5
---
Makefile | 3 +
config.def.h | 6 +
config.mk | 4 +-
dwm.c | 588 +++++++++++++++++++++++++++++++++++++++++++++++++--
dwmswallow | 120 +++++++++++
util.c | 29 +++
util.h | 1 +
7 files changed, 728 insertions(+), 23 deletions(-)
create mode 100644 dwmswallow
diff --git a/Makefile b/Makefile
index ffa69b4..67aa239 100644
--- a/Makefile
+++ b/Makefile
@@ -34,12 +34,15 @@ install: all
mkdir -p ${DESTDIR}${PREFIX}/bin
cp -f dwm ${DESTDIR}${PREFIX}/bin
chmod 755 ${DESTDIR}${PREFIX}/bin/dwm
+ cp -f dwmswallow ${DESTDIR}${PREFIX}/bin
+ chmod 755 ${DESTDIR}${PREFIX}/bin/dwmswallow
mkdir -p ${DESTDIR}${MANPREFIX}/man1
sed "s/VERSION/${VERSION}/g" < dwm.1 > ${DESTDIR}${MANPREFIX}/man1/dwm.1
chmod 644 ${DESTDIR}${MANPREFIX}/man1/dwm.1
uninstall:
rm -f ${DESTDIR}${PREFIX}/bin/dwm\
+ ${DESTDIR}${MANPREFIX}/bin/dwmswallow\
${DESTDIR}${MANPREFIX}/man1/dwm.1
.PHONY: all clean dist install uninstall
diff --git a/config.def.h b/config.def.h
index 9efa774..bf94c30 100644
--- a/config.def.h
+++ b/config.def.h
@@ -30,6 +30,10 @@ static const Rule rules[] = {
{ "Gimp", NULL, NULL, 0, 1, -1 },
{ "Firefox", NULL, NULL, 1 << 8, 0, -1 },
};
+/* window swallowing */
+static const int swaldecay = 3;
+static const int swalretroactive = 1;
+static const char swalsymbol[] = "👅";
/* layout(s) */
static const float mfact = 0.55; /* factor of master area size [0.05..0.95] */
@@ -85,6 +89,7 @@ static const Key keys[] = {
{ MODKEY, XK_period, focusmon, {.i = +1 } },
{ MODKEY|ShiftMask, XK_comma, tagmon, {.i = -1 } },
{ MODKEY|ShiftMask, XK_period, tagmon, {.i = +1 } },
+ { MODKEY, XK_u, swalstopsel, {0} },
TAGKEYS( XK_1, 0)
TAGKEYS( XK_2, 1)
TAGKEYS( XK_3, 2)
@@ -108,6 +113,7 @@ static const Button buttons[] = {
{ ClkClientWin, MODKEY, Button1, movemouse, {0} },
{ ClkClientWin, MODKEY, Button2, togglefloating, {0} },
{ ClkClientWin, MODKEY, Button3, resizemouse, {0} },
+ { ClkClientWin, MODKEY|ShiftMask, Button1, swalmouse, {0} },
{ ClkTagBar, 0, Button1, view, {0} },
{ ClkTagBar, 0, Button3, toggleview, {0} },
{ ClkTagBar, MODKEY, Button1, tag, {0} },
diff --git a/config.mk b/config.mk
index 8efca9a..6a1883c 100644
--- a/config.mk
+++ b/config.mk
@@ -27,8 +27,8 @@ LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS}
# flags
CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS}
-#CFLAGS = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS}
-CFLAGS = -std=c99 -pedantic -Wall -Wno-deprecated-declarations -Os ${INCS} ${CPPFLAGS}
+CFLAGS = -g -std=c99 -pedantic -Wall -O0 ${INCS} ${CPPFLAGS}
+#CFLAGS = -std=c99 -pedantic -Wall -Wno-deprecated-declarations -Os ${INCS} ${CPPFLAGS}
LDFLAGS = ${LIBS}
# Solaris
diff --git a/dwm.c b/dwm.c
index f1d86b2..c01cf41 100644
--- a/dwm.c
+++ b/dwm.c
@@ -58,7 +58,7 @@
#define TEXTW(X) (drw_fontset_getwidth(drw, (X)) + lrpad)
/* enums */
-enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */
+enum { CurNormal, CurResize, CurMove, CurSwal, CurLast }; /* cursor */
enum { SchemeNorm, SchemeSel }; /* color schemes */
enum { NetSupported, NetWMName, NetWMState, NetWMCheck,
NetWMFullscreen, NetActiveWindow, NetWMWindowType,
@@ -66,6 +66,7 @@ enum { NetSupported, NetWMName, NetWMState, NetWMCheck,
enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms */
enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,
ClkClientWin, ClkRootWin, ClkLast }; /* clicks */
+enum { ClientRegular = 1, ClientSwallowee, ClientSwallower }; /* client types */
typedef union {
int i;
@@ -95,6 +96,7 @@ struct Client {
int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen;
Client *next;
Client *snext;
+ Client *swer; /* swallower of client, NULL by default */
Monitor *mon;
Window win;
};
@@ -140,6 +142,27 @@ typedef struct {
int isfloating;
int monitor;
} Rule;
+typedef struct Swallow Swallow;
+struct Swallow {
+ /* Window class name, instance name (WM_CLASS) and title
+ * (WM_NAME/_NET_WM_NAME, latter preferred if it exists). An empty string
+ * implies a wildcard as per strstr(). */
+ char class[256];
+ char inst[256];
+ char title[256];
+
+ /* Used to delete swallow instance after 'swaldecay' windows were mapped
+ * without the swallow having been consumed. 'decay' keeps track of the
+ * remaining "charges". */
+ int decay;
+
+ /* The swallower, i.e. the client which will swallow the next mapped window
+ * whose filters match the above properties. */
+ Client *client;
+
+ /* Linked list of registered swallow instances. */
+ Swallow *next;
+};
/* function declarations */
static void applyrules(Client *c);
@@ -165,6 +188,7 @@ static void drawbar(Monitor *m);
static void drawbars(void);
static void enternotify(XEvent *e);
static void expose(XEvent *e);
+static int fakesignal(void);
static void focus(Client *c);
static void focusin(XEvent *e);
static void focusmon(const Arg *arg);
@@ -206,6 +230,16 @@ static void setup(void);
static void seturgent(Client *c, int urg);
static void showhide(Client *c);
static void spawn(const Arg *arg);
+static void swal(Client *swer, Client *swee, int manage);
+static void swalreg(Client *c, const char* class, const char* inst, const char* title);
+static void swaldecayby(int decayby);
+static void swalmanage(Swallow *s, Window w, XWindowAttributes *wa);
+static Swallow *swalmatch(Window w);
+static void swalmouse(const Arg *arg);
+static void swalrm(Swallow *s);
+static void swalunreg(Client *c);
+static void swalstop(Client *c, Client *root);
+static void swalstopsel(const Arg *unused);
static void tag(const Arg *arg);
static void tagmon(const Arg *arg);
static void tile(Monitor *m);
@@ -228,6 +262,7 @@ static void updatewindowtype(Client *c);
static void updatewmhints(Client *c);
static void view(const Arg *arg);
static Client *wintoclient(Window w);
+static int wintoclient2(Window w, Client **pc, Client **proot);
static Monitor *wintomon(Window w);
static int xerror(Display *dpy, XErrorEvent *ee);
static int xerrordummy(Display *dpy, XErrorEvent *ee);
@@ -266,6 +301,7 @@ static Clr **scheme;
static Display *dpy;
static Drw *drw;
static Monitor *mons, *selmon;
+static Swallow *swallows;
static Window root, wmcheckwin;
/* configuration, allows nested code to access above variables */
@@ -586,7 +622,9 @@ configurerequest(XEvent *e)
XConfigureRequestEvent *ev = &e->xconfigurerequest;
XWindowChanges wc;
- if ((c = wintoclient(ev->window))) {
+ switch (wintoclient2(ev->window, &c, NULL)) {
+ case ClientRegular: /* fallthrough */
+ case ClientSwallowee:
if (ev->value_mask & CWBorderWidth)
c->bw = ev->border_width;
else if (c->isfloating || !selmon->lt[selmon->sellt]->arrange) {
@@ -617,7 +655,13 @@ configurerequest(XEvent *e)
XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h);
} else
configure(c);
- } else {
+ break;
+ case ClientSwallower:
+ /* Reject any move/resize requests for swallowers and communicate
+ * refusal to client via a synthetic ConfigureNotify (ICCCM 4.1.5). */
+ configure(c);
+ break;
+ default:
wc.x = ev->x;
wc.y = ev->y;
wc.width = ev->width;
@@ -626,6 +670,7 @@ configurerequest(XEvent *e)
wc.sibling = ev->above;
wc.stack_mode = ev->detail;
XConfigureWindow(dpy, ev->window, ev->value_mask, &wc);
+ break;
}
XSync(dpy, False);
}
@@ -650,11 +695,30 @@ createmon(void)
void
destroynotify(XEvent *e)
{
- Client *c;
+ Client *c, *swee, *root;
XDestroyWindowEvent *ev = &e->xdestroywindow;
- if ((c = wintoclient(ev->window)))
+ switch (wintoclient2(ev->window, &c, &root)) {
+ case ClientRegular:
unmanage(c, 1);
+ break;
+ case ClientSwallowee:
+ swalstop(c, NULL);
+ unmanage(c, 1);
+ break;
+ case ClientSwallower:
+ /* If the swallower is swallowed by another client, terminate the
+ * swallow. This cuts off the swallow chain after the client. */
+ swalstop(c, root);
+
+ /* Cut off the swallow chain before the client. */
+ for (swee = root; swee->swer != c; swee = swee->swer);
+ swee->swer = NULL;
+
+ free(c);
+ updateclientlist();
+ break;
+ }
}
void
@@ -734,6 +798,12 @@ drawbar(Monitor *m)
drw_setscheme(drw, scheme[SchemeNorm]);
x = drw_text(drw, x, 0, w, bh, lrpad / 2, m->ltsymbol, 0);
+ /* Draw swalsymbol next to ltsymbol. */
+ if (m->sel && m->sel->swer) {
+ w = TEXTW(swalsymbol);
+ x = drw_text(drw, x, 0, w, bh, lrpad / 2, swalsymbol, 0);
+ }
+
if ((w = m->ww - tw - x) > bh) {
if (m->sel) {
drw_setscheme(drw, scheme[m == selmon ? SchemeSel : SchemeNorm]);
@@ -786,6 +856,81 @@ expose(XEvent *e)
drawbar(m);
}
+int
+fakesignal(void)
+{
+ /* Command syntax: <PREFIX><COMMAND>[<SEP><ARG>]... */
+ static const char sep[] = "###";
+ static const char prefix[] = "#!";
+
+ size_t numsegments, numargs;
+ char rootname[256];
+ char *segments[16] = {0};
+
+ /* Get root name, split by separator and find the prefix */
+ if (!gettextprop(root, XA_WM_NAME, rootname, sizeof(rootname))
+ || strncmp(rootname, prefix, sizeof(prefix) - 1)) {
+ return 0;
+ }
+ numsegments = split(rootname + sizeof(prefix) - 1, sep, segments, sizeof(segments));
+ numargs = numsegments - 1; /* number of arguments to COMMAND */
+
+ if (!strcmp(segments[0], "swalreg")) {
+ /* Params: windowid, [class], [instance], [title] */
+ Window w;
+ Client *c;
+
+ if (numargs >= 1) {
+ w = strtoul(segments[1], NULL, 0);
+ switch (wintoclient2(w, &c, NULL)) {
+ case ClientRegular: /* fallthrough */
+ case ClientSwallowee:
+ swalreg(c, segments[2], segments[3], segments[4]);
+ break;
+ }
+ }
+ }
+ else if (!strcmp(segments[0], "swal")) {
+ /* Params: swallower's windowid, swallowee's window-id */
+ Client *swer, *swee;
+ Window winswer, winswee;
+ int typeswer, typeswee;
+
+ if (numargs >= 2) {
+ winswer = strtoul(segments[1], NULL, 0);
+ typeswer = wintoclient2(winswer, &swer, NULL);
+ winswee = strtoul(segments[2], NULL, 0);
+ typeswee = wintoclient2(winswee, &swee, NULL);
+ if ((typeswer == ClientRegular || typeswer == ClientSwallowee)
+ && (typeswee == ClientRegular || typeswee == ClientSwallowee))
+ swal(swer, swee, 0);
+ }
+ }
+ else if (!strcmp(segments[0], "swalunreg")) {
+ /* Params: swallower's windowid */
+ Client *swer;
+ Window winswer;
+
+ if (numargs == 1) {
+ winswer = strtoul(segments[1], NULL, 0);
+ if ((swer = wintoclient(winswer)))
+ swalunreg(swer);
+ }
+ }
+ else if (!strcmp(segments[0], "swalstop")) {
+ /* Params: swallowee's windowid */
+ Client *swee;
+ Window winswee;
+
+ if (numargs == 1) {
+ winswee = strtoul(segments[1], NULL, 0);
+ if ((swee = wintoclient(winswee)))
+ swalstop(swee, NULL);
+ }
+ }
+ return 1;
+}
+
void
focus(Client *c)
{
@@ -1101,13 +1246,35 @@ mappingnotify(XEvent *e)
void
maprequest(XEvent *e)
{
+ Client *c, *swee, *root;
static XWindowAttributes wa;
XMapRequestEvent *ev = &e->xmaprequest;
+ Swallow *s;
if (!XGetWindowAttributes(dpy, ev->window, &wa) || wa.override_redirect)
return;
- if (!wintoclient(ev->window))
- manage(ev->window, &wa);
+ switch (wintoclient2(ev->window, &c, &root)) {
+ case ClientRegular: /* fallthrough */
+ case ClientSwallowee:
+ /* Regulars and swallowees are always mapped. Nothing to do. */
+ break;
+ case ClientSwallower:
+ /* Remapping a swallower will simply stop the swallow. */
+ for (swee = root; swee->swer != c; swee = swee->swer);
+ swalstop(swee, root);
+ break;
+ default:
+ /* No client is managing the window. See if any swallows match. */
+ if ((s = swalmatch(ev->window)))
+ swalmanage(s, ev->window, &wa);
+ else
+ manage(ev->window, &wa);
+ break;
+ }
+
+ /* Reduce decay counter of all swallow instances. */
+ if (swaldecay)
+ swaldecayby(1);
}
void
@@ -1223,11 +1390,13 @@ propertynotify(XEvent *e)
{
Client *c;
Window trans;
+ Swallow *s;
XPropertyEvent *ev = &e->xproperty;
- if ((ev->window == root) && (ev->atom == XA_WM_NAME))
- updatestatus();
- else if (ev->state == PropertyDelete)
+ if ((ev->window == root) && (ev->atom == XA_WM_NAME)) {
+ if (!fakesignal())
+ updatestatus();
+ } else if (ev->state == PropertyDelete)
return; /* ignore */
else if ((c = wintoclient(ev->window))) {
switch(ev->atom) {
@@ -1249,6 +1418,9 @@ propertynotify(XEvent *e)
updatetitle(c);
if (c == c->mon->sel)
drawbar(c->mon);
+ if (swalretroactive && (s = swalmatch(c->win))) {
+ swal(s->client, c, 0);
+ }
}
if (ev->atom == netatom[NetWMWindowType])
updatewindowtype(c);
@@ -1583,6 +1755,7 @@ setup(void)
cursor[CurNormal] = drw_cur_create(drw, XC_left_ptr);
cursor[CurResize] = drw_cur_create(drw, XC_sizing);
cursor[CurMove] = drw_cur_create(drw, XC_fleur);
+ cursor[CurSwal] = drw_cur_create(drw, XC_bottom_side);
/* init appearance */
scheme = ecalloc(LENGTH(colors), sizeof(Clr *));
for (i = 0; i < LENGTH(colors); i++)
@@ -1666,6 +1839,326 @@ spawn(const Arg *arg)
}
}
+/*
+ * Perform immediate swallow of client 'swee' by client 'swer'. 'manage' shall
+ * be set if swal() is called from swalmanage(). 'swer' and 'swee' must be
+ * regular or swallowee, but not swallower.
+ */
+void
+swal(Client *swer, Client *swee, int manage)
+{
+ Client *c, **pc;
+ int sweefocused = selmon->sel == swee;
+
+ /* No self-swallowing! */
+ if (swer == swee)
+ return;
+
+ /* Remove any swallows registered for the swer. Asking a swallower to
+ * swallow another window is ambiguous and is thus avoided altogether. In
+ * contrast, a swallowee can swallow in a well-defined manner by attaching
+ * to the head of the swallow chain. */
+ if (!manage)
+ swalunreg(swer);
+
+ /* Disable fullscreen prior to swallow. Swallows involving fullscreen
+ * windows produces quirky artefacts such as fullscreen terminals or tiled
+ * pseudo-fullscreen windows. */
+ setfullscreen(swer, 0);
+ setfullscreen(swee, 0);
+
+ /* Swap swallowee into client and focus lists. Keeps current focus unless
+ * the swer (which gets unmapped) is focused in which case the swee will
+ * receive focus. */
+ detach(swee);
+ for (pc = &swer->mon->clients; *pc && *pc != swer; pc = &(*pc)->next);
+ *pc = swee;
+ swee->next = swer->next;
+ detachstack(swee);
+ for (pc = &swer->mon->stack; *pc && *pc != swer; pc = &(*pc)->snext);
+ *pc = swee;
+ swee->snext = swer->snext;
+ swee->mon = swer->mon;
+ if (sweefocused) {
+ detachstack(swee);
+ attachstack(swee);
+ selmon = swer->mon;
+ }
+ swee->tags = swer->tags;
+ swee->isfloating = swer->isfloating;
+ for (c = swee; c->swer; c = c->swer);
+ c->swer = swer;
+
+ /* Configure geometry params obtained from patches (e.g. cfacts) here. */
+ // swee->cfact = swer->cfact;
+
+ /* ICCCM 4.1.3.1 */
+ setclientstate(swer, WithdrawnState);
+ if (manage)
+ setclientstate(swee, NormalState);
+
+ if (swee->isfloating || !swee->mon->lt[swee->mon->sellt]->arrange)
+ XRaiseWindow(dpy, swee->win);
+ resize(swee, swer->x, swer->y, swer->w, swer->h, 0);
+
+ focus(NULL);
+ arrange(NULL);
+ if (manage)
+ XMapWindow(dpy, swee->win);
+ XUnmapWindow(dpy, swer->win);
+ restack(swer->mon);
+}
+
+/*
+ * Register a future swallow with swallower 'c'. 'class', 'inst' and 'title'
+ * shall point null-terminated strings and must not be NULL. If an already
+ * existing swallow instance targets 'c' its filters are updated and no new
+ * swallow instance is created. 'c' may be ClientRegular or ClientSwallowee.
+ * Complement to swalrm().
+ */
+void
+swalreg(Client *c, const char *class, const char *inst, const char *title)
+{
+ Swallow *s;
+
+ if (!c)
+ return;
+
+ /* Update existing swallow */
+ for (s = swallows; s; s = s->next) {
+ if (s->client == c) {
+ strncpy(s->class, class, sizeof(s->class) - 1);
+ strncpy(s->inst, inst, sizeof(s->inst) - 1);
+ strncpy(s->title, title, sizeof(s->title) - 1);
+ s->decay = swaldecay;
+
+ /* Only one swallow per client. May return after first hit. */
+ return;
+ }
+ }
+
+ s = ecalloc(1, sizeof(Swallow));
+ s->decay = swaldecay;
+ s->client = c;
+ strncpy(s->class, class, sizeof(s->class) - 1);
+ strncpy(s->inst, inst, sizeof(s->inst) - 1);
+ strncpy(s->title, title, sizeof(s->title) - 1);
+
+ s->next = swallows;
+ swallows = s;
+}
+
+/*
+ * Decrease decay counter of all registered swallows by 'decayby' and remove any
+ * swallow instances whose counter is less than or equal to zero.
+ */
+void
+swaldecayby(int decayby)
+{
+ Swallow *s, *t;
+
+ for (s = swallows; s; s = t) {
+ s->decay -= decayby;
+ t = s->next;
+ if (s->decay <= 0)
+ swalrm(s);
+ }
+}
+
+/*
+ * Window configuration and client setup for new windows which are to be
+ * swallowed immediately. Pendant to manage() for such windows.
+ */
+void
+swalmanage(Swallow *s, Window w, XWindowAttributes *wa)
+{
+ Client *swee, *swer;
+ XWindowChanges wc;
+
+ swer = s->client;
+ swalrm(s);
+
+ /* Perform bare minimum setup of a client for window 'w' such that swal()
+ * may be used to perform the swallow. The following lines are basically a
+ * minimal implementation of manage() with a few chunks delegated to
+ * swal(). */
+ swee = ecalloc(1, sizeof(Client));
+ swee->win = w;
+ swee->mon = swer->mon;
+ swee->oldbw = wa->border_width;
+ swee->bw = borderpx;
+ attach(swee);
+ attachstack(swee);
+ updatetitle(swee);
+ updatesizehints(swee);
+ XSelectInput(dpy, swee->win, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
+ wc.border_width = swee->bw;
+ XConfigureWindow(dpy, swee->win, CWBorderWidth, &wc);
+ grabbuttons(swee, 0);
+ XChangeProperty(dpy, root, netatom[NetClientList], XA_WINDOW, 32, PropModeAppend,
+ (unsigned char *) &(swee->win), 1);
+
+ swal(swer, swee, 1);
+}
+
+/*
+ * Return swallow instance which targets window 'w' as determined by its class
+ * name, instance name and window title. Returns NULL if none is found. Pendant
+ * to wintoclient().
+ */
+Swallow *
+swalmatch(Window w)
+{
+ XClassHint ch = { NULL, NULL };
+ Swallow *s = NULL;
+ char title[sizeof(s->title)];
+
+ XGetClassHint(dpy, w, &ch);
+ if (!gettextprop(w, netatom[NetWMName], title, sizeof(title)))
+ gettextprop(w, XA_WM_NAME, title, sizeof(title));
+
+ for (s = swallows; s; s = s->next) {
+ if ((!ch.res_class || strstr(ch.res_class, s->class))
+ && (!ch.res_name || strstr(ch.res_name, s->inst))
+ && (title[0] == '\0' || strstr(title, s->title)))
+ break;
+ }
+
+ if (ch.res_class)
+ XFree(ch.res_class);
+ if (ch.res_name)
+ XFree(ch.res_name);
+ return s;
+}
+
+/*
+ * Interactive drag-and-drop swallow.
+ */
+void
+swalmouse(const Arg *arg)
+{
+ Client *swer, *swee;
+ XEvent ev;
+
+ if (!(swee = selmon->sel))
+ return;
+
+ if (XGrabPointer(dpy, root, False, ButtonPressMask|ButtonReleaseMask, GrabModeAsync,
+ GrabModeAsync, None, cursor[CurSwal]->cursor, CurrentTime) != GrabSuccess)
+ return;
+
+ do {
+ XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev);
+ switch(ev.type) {
+ case ConfigureRequest: /* fallthrough */
+ case Expose: /* fallthrough */
+ case MapRequest:
+ handler[ev.type](&ev);
+ break;
+ }
+ } while (ev.type != ButtonRelease);
+ XUngrabPointer(dpy, CurrentTime);
+
+ if ((swer = wintoclient(ev.xbutton.subwindow))
+ && swer != swee)
+ swal(swer, swee, 0);
+
+ /* Remove accumulated pending EnterWindow events caused by the mouse
+ * movements. */
+ XCheckMaskEvent(dpy, EnterWindowMask, &ev);
+}
+
+/*
+ * Delete swallow instance swallows and free its resources. Complement to
+ * swalreg(). If NULL is passed all registered swallows are deleted.
+ */
+void
+swalrm(Swallow *s)
+{
+ Swallow *t, **ps;
+
+ if (s) {
+ for (ps = &swallows; *ps && *ps != s; ps = &(*ps)->next);
+ *ps = s->next;
+ free(s);
+ }
+ else {
+ for(s = swallows; s; s = t) {
+ t = s->next;
+ free(s);
+ }
+ swallows = NULL;
+ }
+}
+
+/*
+ * Removes swallow instance targeting 'c' if it exists. Complement to swalreg().
+ */
+void
+swalunreg(Client *c) { Swallow *s;
+
+ for (s = swallows; s; s = s->next) {
+ if (c == s->client) {
+ swalrm(s);
+ /* Max. 1 registered swallow per client. No need to continue. */
+ break;
+ }
+ }
+}
+
+/*
+ * Stop an active swallow of swallowed client 'swee' and remap the swallower.
+ * If 'swee' is a swallower itself 'root' must point the root client of the
+ * swallow chain containing 'swee'.
+ */
+void
+swalstop(Client *swee, Client *root)
+{
+ Client *swer;
+
+ if (!swee || !(swer = swee->swer))
+ return;
+
+ swee->swer = NULL;
+ root = root ? root : swee;
+ swer->mon = root->mon;
+ swer->tags = root->tags;
+ swer->next = root->next;
+ root->next = swer;
+ swer->snext = root->snext;
+ root->snext = swer;
+ swer->isfloating = swee->isfloating;
+
+ /* Configure geometry params obtained from patches (e.g. cfacts) here. */
+ // swer->cfact = 1.0;
+
+ /* If swer is not in tiling mode reuse swee's geometry. */
+ if (swer->isfloating || !root->mon->lt[root->mon->sellt]->arrange) {
+ XRaiseWindow(dpy, swer->win);
+ resize(swer, swee->x, swee->y, swee->w, swee->h, 0);
+ }
+
+ /* Override swer's border scheme which may be using SchemeSel. */
+ XSetWindowBorder(dpy, swer->win, scheme[SchemeNorm][ColBorder].pixel);
+
+ /* ICCCM 4.1.3.1 */
+ setclientstate(swer, NormalState);
+
+ XMapWindow(dpy, swer->win);
+ focus(NULL);
+ arrange(swer->mon);
+}
+
+/*
+ * Stop active swallow for currently selected client.
+ */
+void
+swalstopsel(const Arg *unused)
+{
+ if (selmon->sel)
+ swalstop(selmon->sel, NULL);
+}
+
void
tag(const Arg *arg)
{
@@ -1806,12 +2299,24 @@ unmapnotify(XEvent *e)
{
Client *c;
XUnmapEvent *ev = &e->xunmap;
+ int type;
- if ((c = wintoclient(ev->window))) {
- if (ev->send_event)
- setclientstate(c, WithdrawnState);
- else
- unmanage(c, 0);
+ type = wintoclient2(ev->window, &c, NULL);
+ if (type && ev->send_event) {
+ setclientstate(c, WithdrawnState);
+ return;
+ }
+ switch (type) {
+ case ClientRegular:
+ unmanage(c, 0);
+ break;
+ case ClientSwallowee:
+ swalstop(c, NULL);
+ unmanage(c, 0);
+ break;
+ case ClientSwallower:
+ /* Swallowers are never mapped. Nothing to do. */
+ break;
}
}
@@ -1853,15 +2358,19 @@ updatebarpos(Monitor *m)
void
updateclientlist()
{
- Client *c;
+ Client *c, *d;
Monitor *m;
XDeleteProperty(dpy, root, netatom[NetClientList]);
- for (m = mons; m; m = m->next)
- for (c = m->clients; c; c = c->next)
- XChangeProperty(dpy, root, netatom[NetClientList],
- XA_WINDOW, 32, PropModeAppend,
- (unsigned char *) &(c->win), 1);
+ for (m = mons; m; m = m->next) {
+ for (c = m->clients; c; c = c->next) {
+ for (d = c; d; d = d->swer) {
+ XChangeProperty(dpy, root, netatom[NetClientList],
+ XA_WINDOW, 32, PropModeAppend,
+ (unsigned char *) &(c->win), 1);
+ }
+ }
+ }
}
int
@@ -2075,6 +2584,43 @@ wintoclient(Window w)
return NULL;
}
+/*
+ * Writes client managing window 'w' into 'pc' and returns type of client. If
+ * no client is found NULL is written to 'pc' and zero is returned. If a client
+ * is found and is a swallower (ClientSwallower) and proot is not NULL the root
+ * client of the swallow chain is written to 'proot'.
+ */
+int
+wintoclient2(Window w, Client **pc, Client **proot)
+{
+ Monitor *m;
+ Client *c, *d;
+
+ for (m = mons; m; m = m->next) {
+ for (c = m->clients; c; c = c->next) {
+ if (c->win == w) {
+ *pc = c;
+ if (c->swer)
+ return ClientSwallowee;
+ else
+ return ClientRegular;
+ }
+ else {
+ for (d = c->swer; d; d = d->swer) {
+ if (d->win == w) {
+ if (proot)
+ *proot = c;
+ *pc = d;
+ return ClientSwallower;
+ }
+ }
+ }
+ }
+ }
+ *pc = NULL;
+ return 0;
+}
+
Monitor *
wintomon(Window w)
{
diff --git a/dwmswallow b/dwmswallow
new file mode 100644
index 0000000..eaab3bb
--- /dev/null
+++ b/dwmswallow
@@ -0,0 +1,120 @@
+#!/usr/bin/env sh
+
+# Separator and command prefix, as defined in dwm.c:fakesignal()
+SEP='###'
+PREFIX='#!'
+
+# Asserts that all arguments are valid X11 window IDs, i.e. positive integers.
+# For the purpose of this script 0 is declared invalid.
+is_winid() {
+ while :; do
+ # Given input incompatible to %d, some implementations of printf return
+ # an error while others silently evaluate the expression to 0.
+ if ! wid=$(printf '%d' "$1" 2>/dev/null) || [ "$wid" -le 0 ]; then
+ return 1
+ fi
+
+ [ -n "$2" ] && shift || break
+ done
+}
+
+# Prints usage help. If "$1" is provided, function exits script after
+# execution.
+usage() {
+ [ -t 1 ] && myprintf=printf || myprintf=true
+ msg="$(cat <<-EOF
+ dwm window swallowing command-line interface. Usage:
+
+ $($myprintf "\033[1m")dwmswallow $($myprintf "\033[3m")SWALLOWER [-c CLASS] [-i INSTANCE] [-t TITLE]$($myprintf "\033[0m")
+ Register window $($myprintf "\033[3m")SWALLOWER$($myprintf "\033[0m") to swallow the next future window whose attributes
+ match the $($myprintf "\033[3m")CLASS$($myprintf "\033[0m") name, $($myprintf "\033[3m")INSTANCE$($myprintf "\033[0m") name and window $($myprintf "\033[3m")TITLE$($myprintf "\033[0m") filters using basic
+ string-matching. An omitted filter will match anything.
+
+ $($myprintf "\033[1m")dwmswallow $($myprintf "\033[3m")SWALLOWER -d$($myprintf "\033[0m")
+ Deregister queued swallow for window $($myprintf "\033[3m")SWALLOWER$($myprintf "\033[0m"). Inverse of above signature.
+
+ $($myprintf "\033[1m")dwmswallow $($myprintf "\033[3m")SWALLOWER SWALLOWEE$($myprintf "\033[0m")
+ Perform immediate swallow of window $($myprintf "\033[3m")SWALLOWEE$($myprintf "\033[0m") by window $($myprintf "\033[3m")SWALLOWER$($myprintf "\033[0m").
+
+ $($myprintf "\033[1m")dwmswallow $($myprintf "\033[3m")SWALLOWEE -s$($myprintf "\033[0m")
+ Stop swallow of window $($myprintf "\033[3m")SWALLOWEE$($myprintf "\033[0m"). Inverse of the above signature. Visible
+ windows only.
+
+ $($myprintf "\033[1m")dwmswallow -h$($myprintf "\033[0m")
+ Show this usage information.
+ EOF
+ )"
+
+ if [ -n "$1" ]; then
+ echo "$msg" >&2
+ exit "$1"
+ else
+ echo "$msg"
+ fi
+}
+
+# Determine number of leading positional arguments
+arg1="$1" # save for later
+arg2="$2" # save for later
+num_pargs=0
+while :; do
+ case "$1" in
+ -*|"") break ;;
+ *) num_pargs=$((num_pargs + 1)); shift ;;
+ esac
+done
+
+case "$num_pargs" in
+1)
+ ! is_winid "$arg1" && usage 1
+
+ widswer="$arg1"
+ if [ "$1" = "-d" ] && [ "$#" -eq 1 ]; then
+ if name="$(printf "${PREFIX}swalunreg${SEP}%u" "$widswer" 2>/dev/null)"; then
+ xsetroot -name "$name"
+ else
+ usage 1
+ fi
+ elif [ "$1" = "-s" ] && [ "$#" -eq 1 ]; then
+ widswee="$arg1"
+ if name="$(printf "${PREFIX}swalstop${SEP}%u" "$widswee" 2>/dev/null)"; then
+ xsetroot -name "$name"
+ else
+ usage 1
+ fi
+ else
+ while :; do
+ case "$1" in
+ -c) [ -n "$2" ] && { class="$2"; shift 2; } || usage 1 ;;
+ -i) [ -n "$2" ] && { instance="$2"; shift 2; } || usage 1 ;;
+ -t) [ -n "$2" ] && { title="$2"; shift 2; } || usage 1 ;;
+ "") break ;;
+ *) usage 1 ;;
+ esac
+ done
+ widswer="$arg1"
+ if name="$(printf "${PREFIX}swalreg${SEP}%u${SEP}%s${SEP}%s${SEP}%s" "$widswer" "$class" "$instance" "$title" 2>/dev/null)"; then
+ xsetroot -name "$name"
+ else
+ usage 1
+ fi
+ fi
+ ;;
+2)
+ ! is_winid "$arg1" "$arg2" || [ -n "$1" ] && usage 1
+
+ widswer="$arg1"
+ widswee="$arg2"
+ if name="$(printf "${PREFIX}swal${SEP}%u${SEP}%u" "$widswer" "$widswee" 2>/dev/null)"; then
+ xsetroot -name "$name"
+ else
+ usage 1
+ fi
+ ;;
+*)
+ if [ "$arg1" = "-h" ] && [ $# -eq 1 ]; then
+ usage
+ else
+ usage 1
+ fi
+esac
diff --git a/util.c b/util.c
index 96b82c9..3af7b6c 100644
--- a/util.c
+++ b/util.c
@@ -24,6 +24,35 @@ die(const char *fmt, ...)
exit(1);
}
+/*
+ * Splits a string into segments according to a separator. A '\0' is written to
+ * the end of every segment. The beginning of every segment is written to
+ * 'pbegin'. Only the first 'maxcount' segments will be written if
+ * maxcount > 0. Inspired by python's split.
+ *
+ * Used exclusively by fakesignal() to split arguments.
+ */
+size_t
+split(char *s, const char* sep, char **pbegin, size_t maxcount) {
+
+ char *p, *q;
+ const size_t seplen = strlen(sep);
+ size_t count = 0;
+
+ maxcount = maxcount == 0 ? (size_t)-1 : maxcount;
+ p = s;
+ while ((q = strstr(p, sep)) != NULL && count < maxcount) {
+ pbegin[count] = p;
+ *q = '\0';
+ p = q + seplen;
+ count++;
+ }
+ if (count < maxcount) {
+ pbegin[count] = p;
+ count++;
+ }
+ return count;
+}
void *
ecalloc(size_t nmemb, size_t size)
diff --git a/util.h b/util.h
index f633b51..670345f 100644
--- a/util.h
+++ b/util.h
@@ -6,3 +6,4 @@
void die(const char *fmt, ...);
void *ecalloc(size_t nmemb, size_t size);
+size_t split(char *s, const char* sep, char **pbegin, size_t maxcount);
--
2.44.0
Reference in a new issue View git blame Copy permalink