fix awesomebar overdraw on statusbar:x

2026-07-11 23:05:15 +02:00
parent 79e342426a
commit e9a681783b
9 changed files with 979 additions and 670 deletions
--- a/dwm.c.orig
+++ b/dwm.c.orig
@@ -25,6 +25,7 @@
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ -51,6 +52,7 @@
                               * MAX(0, MIN((y)+(h),(m)->wy+(m)->wh) - MAX((y),(m)->wy)))
 #define ISVISIBLEONTAG(C, T)    ((C->tags & T))
 #define ISVISIBLE(C)            ISVISIBLEONTAG(C, C->mon->tagset[C->mon->seltags])
+#define HIDDEN(C)               ((getstate(C->win) == IconicState))
 #define MOUSEMASK               (BUTTONMASK|PointerMotionMask)
 #define WIDTH(X)                ((X)->w + 2 * (X)->bw)
 #define HEIGHT(X)               ((X)->h + 2 * (X)->bw)
@@ -76,8 +78,8 @@

 /* enums */
 enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */
-enum { SchemeNorm, SchemeSel }; /* color schemes */
-enum { NetSupported, NetWMName, NetWMState, NetWMCheck,
+enum { SchemeNorm, SchemeSel, SchemeHid }; /* color schemes */
+enum { NetSupported, NetWMName, NetWMIcon, NetWMState, NetWMCheck,
       NetSystemTray, NetSystemTrayOP, NetSystemTrayOrientation, NetSystemTrayOrientationHorz,
       NetWMFullscreen, NetActiveWindow, NetWMWindowType,
       NetWMWindowTypeDialog, NetClientList, NetClientInfo, NetDesktopNames, NetDesktopViewport, NetNumberOfDesktops, NetCurrentDesktop, NetLast }; /* EWMH atoms */
@@ -113,6 +115,8 @@ struct Client {
 	int bw, oldbw;
 	unsigned int tags;
 	int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen;
+	unsigned int icw, ich;
+	Picture icon;
 	int issteam;
 	int fakefullscreen;
 	Client *next;
@@ -139,6 +143,8 @@ struct Monitor {
 	int nmaster;
 	int num;
 	int by;               /* bar geometry */
+	int btw;              /* width of tasks portion of bar */
+	int bt;               /* number of tasks */
 	int mx, my, mw, mh;   /* screen size */
 	int wx, wy, ww, wh;   /* window area  */
 	int gappih;           /* horizontal gap between windows */
@@ -150,6 +156,7 @@ struct Monitor {
 	unsigned int tagset[2];
 	int showbar;
 	int topbar;
+	int hidsel;
 	Client *clients;
 	Client *sel;
 	Client *stack;
@@ -181,6 +188,7 @@ static void arrangemon(Monitor *m);
 static void attach(Client *c);
 static void attachaside(Client *c);
 static void attachstack(Client *c);
+static uint32_t *bilinear_scale(const uint32_t *src, int sw, int sh, uint32_t dw, uint32_t dh);
 static void buttonpress(XEvent *e);
 static void checkotherwm(void);
 static void cleanup(void);
@@ -203,14 +211,20 @@ static void focus(Client *c);
 static void focusdir(const Arg *arg);
 static void focusin(XEvent *e);
 static void focusmon(const Arg *arg);
-static void focusstack(const Arg *arg);
+static void focusstackvis(const Arg *arg);
+static void focusstackhid(const Arg *arg);
+static void focusstack(int inc, int vis);
+static void freeicon(Client *c);
 static Atom getatomprop(Client *c, Atom prop);
 static int getrootptr(int *x, int *y);
 static long getstate(Window w);
+static Picture geticonprop(Display *dpy, Window w, int iconsize, unsigned int *icw, unsigned int *ich);
 static unsigned int getsystraywidth();
 static int gettextprop(Window w, Atom atom, char *text, unsigned int size);
 static void grabbuttons(Client *c, int focused);
 static void grabkeys(void);
+static void hide(const Arg *arg);
+static void hidewin(Client *c);
 static void incnmaster(const Arg *arg);
 static void keypress(XEvent *e);
 static void killclient(const Arg *arg);
@@ -225,6 +239,7 @@ static Client *nexttagged(Client *c);
 static Client *nexttiled(Client *c);
 static void placedir(const Arg *arg);
 static void pop(Client *c);
+static uint32_t prealpha(uint32_t p);
 static void propertynotify(XEvent *e);
 static void quit(const Arg *arg);
 static Monitor *recttomon(int x, int y, int w, int h);
@@ -253,6 +268,9 @@ static void setnumdesktops(void);
 static void setup(void);
 static void setviewport(void);
 static void seturgent(Client *c, int urg);
+static void show(const Arg *arg);
+static void showall(const Arg *arg);
+static void showwin(Client *c);
 static void showhide(Client *c);
 static void sighup(int unused);
 static void sigterm(int unused);
@@ -267,6 +285,7 @@ static void togglefullscreen(const Arg *arg);
 static void togglescratch(const Arg *arg);
 static void toggletag(const Arg *arg);
 static void toggleview(const Arg *arg);
+static void togglewin(const Arg *arg);
 static void unfocus(Client *c, int setfocus);
 static void unmanage(Client *c, int destroyed);
 static void unmapnotify(XEvent *e);
@@ -275,6 +294,7 @@ static void updatebarpos(Monitor *m);
 static void updatebars(void);
 static void updateclientlist(void);
 static int updategeom(void);
+static void updateicon(Client *c);
 static void updatenumlockmask(void);
 static void updatesizehints(Client *c);
 static void updatestatus(void);
@@ -539,6 +559,57 @@ attachstack(Client *c)
 	c->mon->stack = c;
 }

+uint32_t *
+bilinear_scale(const uint32_t *src, int sw, int sh, unsigned int dw, unsigned int dh)
+{
+	uint32_t *dst = calloc(dw * dh, sizeof(uint32_t));
+	if (!dst) return NULL;
+
+	for (int y = 0; y < dh; y++) {
+		/* Source position (in fixed-point) */
+		float sy = (y + 0.5f) * sh / (float)dh - 0.5f;
+		int y0 = (sy < 0) ? (int)(sy - 1) : (int)(sy);;
+		int y1 = y0 + 1;
+		float fy = sy - y0;
+		if (y0 < 0) { y0 = 0; y1 = 0; fy = 0; }
+		if (y1 >= sh) { y1 = sh-1; y0 = y1; fy = 0; }
+
+		for (int x = 0; x < dw; x++) {
+			float sx = (x + 0.5f) * sw / (float)dw - 0.5f;
+			int x0 = (sx < 0) ? (int)(sx - 1) : (int)(sx);
+			int x1 = x0 + 1;
+			float fx = sx - x0;
+			if (x0 < 0) { x0 = 0; x1 = 0; fx = 0; }
+			if (x1 >= sw) { x1 = sw-1; x0 = x1; fx = 0; }
+
+			uint32_t p00 = prealpha(src[y0*sw + x0]);
+			uint32_t p10 = prealpha(src[y0*sw + x1]);
+			uint32_t p01 = prealpha(src[y1*sw + x0]);
+			uint32_t p11 = prealpha(src[y1*sw + x1]);
+
+			/* Extract premultiplied channels */
+			int a00 = p00 >> 24, r00 = (p00 >> 16) & 0xFF, g00 = (p00 >> 8) & 0xFF, b00 = p00 & 0xFF;
+			int a10 = p10 >> 24, r10 = (p10 >> 16) & 0xFF, g10 = (p10 >> 8) & 0xFF, b10 = p10 & 0xFF;
+			int a01 = p01 >> 24, r01 = (p01 >> 16) & 0xFF, g01 = (p01 >> 8) & 0xFF, b01 = p01 & 0xFF;
+			int a11 = p11 >> 24, r11 = (p11 >> 16) & 0xFF, g11 = (p11 >> 8) & 0xFF, b11 = p11 & 0xFF;
+
+			/* Bilinear weights */
+			float w00 = (1.0f - fx) * (1.0f - fy);
+			float w10 = fx * (1.0f - fy);
+			float w01 = (1.0f - fx) * fy;
+			float w11 = fx * fy;
+
+			int a = (int)(a00*w00 + a10*w10 + a01*w01 + a11*w11 + 0.5f);
+			int r = (int)(r00*w00 + r10*w10 + r01*w01 + r11*w11 + 0.5f);
+			int g = (int)(g00*w00 + g10*w10 + g01*w01 + g11*w11 + 0.5f);
+			int b = (int)(b00*w00 + b10*w10 + b01*w01 + b11*w11 + 0.5f);
+
+			dst[y*dw + x] = (a << 24) | (r << 16) | (g << 8) | b;
+		}
+	}
+	return dst;
+}
+
 void
 buttonpress(XEvent *e)
 {
@@ -565,10 +636,24 @@ buttonpress(XEvent *e)
 			arg.ui = 1 << i;
 		} else if (ev->x < x + TEXTW(selmon->ltsymbol))
 			click = ClkLtSymbol;
-		else if (ev->x > selmon->ww - (int)TEXTW(stext) - getsystraywidth())
+		else if (ev->x > selmon->ww - (int)TEXTW(stext) - getsystraywidth() + lrpad - 2)
 			click = ClkStatusText;
-		else
-			click = ClkWinTitle;
+		else {
+			x += TEXTW(selmon->ltsymbol);
+			c = m->clients;
+
+			if (c) {
+				do {
+					if (!ISVISIBLE(c))
+						continue;
+					else
+						x +=(1.0 / (double)m->bt) * m->btw;
+				} while (ev->x > x && (c = c->next));
+
+				click = ClkWinTitle;
+				arg.v = c;
+			}
+		}
 	} else if ((c = wintoclient(ev->window))) {
 		focus(c);
 		restack(selmon);
@@ -578,7 +663,7 @@ buttonpress(XEvent *e)
 	for (i = 0; i < LENGTH(buttons); i++)
 		if (click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button
 		&& CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
-			buttons[i].func(click == ClkTagBar && buttons[i].arg.i == 0 ? &arg : &buttons[i].arg);
+			buttons[i].func((click == ClkTagBar || click == ClkWinTitle) && buttons[i].arg.i == 0 ? &arg : &buttons[i].arg);
 }

 void
@@ -909,7 +994,7 @@ dirtomon(int dir)
 void
 drawbar(Monitor *m)
 {
-	int x, w, tw = 0, stw = 0;
+	int x, w, tw = 0, stw = 0, n = 0, scm;
 	int boxs = drw->fonts->h / 9;
 	int boxw = drw->fonts->h / 6 + 2;
 	unsigned int i, occ = 0, urg = 0;
@@ -930,6 +1015,8 @@ drawbar(Monitor *m)

 	resizebarwin(m);
 	for (c = m->clients; c; c = c->next) {
+		if (ISVISIBLE(c))
+			n++;
 		occ |= c->tags;
 		if (c->isurgent)
 			urg |= c->tags;
@@ -950,16 +1037,41 @@ drawbar(Monitor *m)
 	x = drw_text(drw, x, 0, w, bh, lrpad / 2, m->ltsymbol, 0);

 	if ((w = m->ww - tw - stw - x) > bh) {
-		if (m->sel) {
-			drw_setscheme(drw, scheme[m == selmon ? SchemeSel : SchemeNorm]);
-			drw_text(drw, x, 0, w, bh, lrpad / 2, m->sel->name, 0);
-			if (m->sel->isfloating)
-				drw_rect(drw, x + boxs, boxs, boxw, boxw, m->sel->isfixed, 0);
+		if (n > 0) {
+			int remainder = w % n;
+			int tabw = (1.0 / (double)n) * w + 1;
+			for (c = m->clients; c; c = c->next) {
+				if (!ISVISIBLE(c))
+					continue;
+				if (m->sel == c)
+					scm = SchemeSel;
+				else if (HIDDEN(c))
+					scm = SchemeHid;
+				else
+					scm = SchemeNorm;
+				drw_setscheme(drw, scheme[scm]);
+
+				if (remainder >= 0) {
+					if (remainder == 0) {
+						tabw--;
+					}
+					remainder--;
+				}
+				if (c->icon) {
+					drw_text(drw, x, 0, w > m->ww - tw - stw - x ? m->ww - tw - stw - x : w, bh, lrpad / 2 + c->ich + iconspacing, c->name, 0);
+					drw_pic(drw, x + lrpad / 2, (bh - c->ich) / 2, c->icw, c->ich, c->icon);
+				} else {
+					drw_text(drw, x, 0, tabw > m->ww - tw - stw - x ? m->ww - tw - stw - x : tabw, bh, lrpad / 2, c->name, 0);
+				}
+				x += tabw;
+			}
 		} else {
 			drw_setscheme(drw, scheme[SchemeNorm]);
 			drw_rect(drw, x, 0, w, bh, 1, 1);
 		}
 	}
+	m->bt = n;
+	m->btw = w;
 	drw_map(drw, m->barwin, 0, 0, m->ww - stw, bh);
 }

@@ -1008,10 +1120,16 @@ void
 focus(Client *c)
 {
 	if (!c || !ISVISIBLE(c))
-		for (c = selmon->stack; c && !ISVISIBLE(c); c = c->snext);
+		for (c = selmon->stack; c && (!ISVISIBLE(c) || HIDDEN(c)); c = c->snext);
 	if (selmon->sel && selmon->sel != c) {
 		losefullscreen(c);
 		unfocus(selmon->sel, 0);
+		if (selmon->hidsel) {
+			hidewin(selmon->sel);
+			if (c)
+				arrange(c->mon);
+			selmon->hidsel = 0;
+		}
 	}
 	if (c) {
 		if (c->mon != selmon)
@@ -1122,28 +1240,62 @@ focusmon(const Arg *arg)
 }

 void
-focusstack(const Arg *arg)
+focusstackvis(const Arg *arg) {
+	focusstack(arg->i, 0);
+}
+
+void
+focusstackhid(const Arg *arg) {
+	focusstack(arg->i, 1);
+}
+
+void
+focusstack(int inc, int hid)
 {
 	Client *c = NULL, *i;

-	if (!selmon->sel || (selmon->sel->isfullscreen && selmon->sel->fakefullscreen != 1))
+	// if no client selected AND exclude hidden client; if client selected but fullscreened
+	if ((!selmon->sel && !hid) || (selmon->sel && selmon->sel->isfullscreen && lockfullscreen))
 		return;
-	if (arg->i > 0) {
-		for (c = selmon->sel->next; c && !ISVISIBLE(c); c = c->next);
+	if (!selmon->clients)
+		return;
+	if (inc > 0) {
+		if (selmon->sel)
+			for (c = selmon->sel->next;
+					c && (!ISVISIBLE(c) || (!hid && HIDDEN(c)));
+					c = c->next);
 		if (!c)
-			for (c = selmon->clients; c && !ISVISIBLE(c); c = c->next);
+			for (c = selmon->clients;
+					c && (!ISVISIBLE(c) || (!hid && HIDDEN(c)));
+					c = c->next);
 	} else {
-		for (i = selmon->clients; i != selmon->sel; i = i->next)
-			if (ISVISIBLE(i))
-				c = i;
+		if (selmon->sel) {
+			for (i = selmon->clients; i != selmon->sel; i = i->next)
+				if (ISVISIBLE(i) && !(!hid && HIDDEN(i)))
+					c = i;
+		} else
+			c = selmon->clients;
 		if (!c)
 			for (; i; i = i->next)
-				if (ISVISIBLE(i))
+				if (ISVISIBLE(i) && !(!hid && HIDDEN(i)))
 					c = i;
 	}
 	if (c) {
 		focus(c);
 		restack(selmon);
+		if (HIDDEN(c)) {
+			showwin(c);
+			c->mon->hidsel = 1;
+		}
+	}
+}
+
+void
+freeicon(Client *c)
+{
+	if (c->icon) {
+		XRenderFreePicture(dpy, c->icon);
+		c->icon = None;
 	}
 }

@@ -1209,6 +1361,104 @@ getstate(Window w)
 	return result;
 }

+/* geticonprop: read, scale, and return an XRender Picture */
+Picture
+geticonprop(Display *dpy, Window win, int iconsize, unsigned int *icw, unsigned int *ich) {
+	Atom net_wm_icon = XInternAtom(dpy, "_NET_WM_ICON", False);
+	Atom actual_type;
+	int actual_format;
+	unsigned long nitems, bytes_after;
+	unsigned char *data = NULL;
+	Picture pict = None;
+
+	if (XGetWindowProperty(dpy, win, net_wm_icon, 0, LONG_MAX, False, AnyPropertyType,
+			&actual_type, &actual_format, &nitems, &bytes_after, &data) != Success || !data) {
+		return None;
+	}
+
+	unsigned long *p = (unsigned long *)data;
+	unsigned long *end = p + nitems;
+
+	/* Pick icon closest to desired size */
+	unsigned long *best = NULL;
+	unsigned long best_w = 0, best_h = 0;
+	unsigned long best_diff = ~0UL;
+
+	while (p + 2 < end) {
+		unsigned long w0 = *p++;
+		unsigned long h0 = *p++;
+		if (w0 == 0 || h0 == 0 || p + w0*h0 > end) break;
+
+		unsigned long diff = (w0 > (unsigned long)iconsize ? w0 - iconsize : iconsize - w0)
+						   + (h0 > (unsigned long)iconsize ? h0 - iconsize : iconsize - h0);
+
+		if (diff < best_diff) {
+			best_diff = diff;
+			best_w = w0;
+			best_h = h0;
+			best = p;
+		}
+		p += w0 * h0;
+	}
+
+	if (!best) {
+		XFree(data);
+		return None;
+	}
+
+	/* Copy into fixed 32-bit array */
+	uint32_t *src = malloc(best_w * best_h * sizeof(uint32_t));
+	for (size_t i = 0; i < best_w * best_h; i++)
+		src[i] = (uint32_t)best[i];
+
+	/* Scale */
+	int dst_w, dst_h;
+	if (best_w > best_h) {
+		dst_w = iconsize;
+		dst_h = best_h * iconsize / best_w;
+	} else {
+		dst_h = iconsize;
+		dst_w = best_w * iconsize / best_h;
+	}
+
+	uint32_t *scaled = bilinear_scale(src, best_w, best_h, dst_w, dst_h);
+	free(src);
+	XFree(data);
+	if (!scaled) return None;
+
+	/* Create pixmap and upload pixels */
+	Pixmap pm = XCreatePixmap(dpy, root, dst_w, dst_h, 32);
+
+	XImage img;
+	memset(&img, 0, sizeof img);
+	img.width = dst_w;
+	img.height = dst_h;
+	img.format = ZPixmap;
+	img.data = (char*)scaled;
+	img.byte_order = LSBFirst;
+	img.bitmap_unit = 32;
+	img.bitmap_bit_order = LSBFirst;
+	img.bitmap_pad = 32;
+	img.depth = 32;
+	img.bits_per_pixel = 32;
+	img.bytes_per_line = dst_w * 4;
+
+	XInitImage(&img);
+	GC gc = XCreateGC(dpy, pm, 0, NULL);
+	XPutImage(dpy, pm, gc, &img, 0, 0, 0, 0, dst_w, dst_h);
+	XFreeGC(dpy, gc);
+
+	XRenderPictFormat *fmt = XRenderFindStandardFormat(dpy, PictStandardARGB32);
+	pict = XRenderCreatePicture(dpy, pm, fmt, 0, NULL);
+	XFreePixmap(dpy, pm);
+
+	free(scaled);
+
+	*icw = dst_w;
+	*ich = dst_h;
+	return pict;
+}
+
 int
 gettextprop(Window w, Atom atom, char *text, unsigned int size)
 {
@@ -1281,6 +1531,36 @@ grabkeys(void)
 	}
 }

+void
+hide(const Arg *arg)
+{
+	hidewin(selmon->sel);
+	focus(NULL);
+	arrange(selmon);
+}
+
+void
+hidewin(Client *c) {
+	if (!c || HIDDEN(c))
+		return;
+
+	Window w = c->win;
+	static XWindowAttributes ra, ca;
+
+	// more or less taken directly from blackbox's hide() function
+	XGrabServer(dpy);
+	XGetWindowAttributes(dpy, root, &ra);
+	XGetWindowAttributes(dpy, w, &ca);
+	// prevent UnmapNotify events
+	XSelectInput(dpy, root, ra.your_event_mask & ~SubstructureNotifyMask);
+	XSelectInput(dpy, w, ca.your_event_mask & ~StructureNotifyMask);
+	XUnmapWindow(dpy, w);
+	setclientstate(c, IconicState);
+	XSelectInput(dpy, root, ra.your_event_mask);
+	XSelectInput(dpy, w, ca.your_event_mask);
+	XUngrabServer(dpy);
+}
+
 void
 incnmaster(const Arg *arg)
 {
@@ -1360,6 +1640,7 @@ manage(Window w, XWindowAttributes *wa)
 	c->oldbw = wa->border_width;
 	c->cfact = 1.0;

+	updateicon(c);
 	updatetitle(c);
 	if (XGetTransientForHint(dpy, w, &trans) && (t = wintoclient(trans))) {
 		c->mon = t->mon;
@@ -1415,14 +1696,16 @@ manage(Window w, XWindowAttributes *wa)
 	XChangeProperty(dpy, root, netatom[NetClientList], XA_WINDOW, 32, PropModeAppend,
 		(unsigned char *) &(c->win), 1);
 	XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */
-	setclientstate(c, NormalState);
+	if (!HIDDEN(c))
+		setclientstate(c, NormalState);
 	if (c->mon == selmon) {
 		losefullscreen(c);
 		unfocus(selmon->sel, 0);
 	}
 	c->mon->sel = c;
 	arrange(c->mon);
-	XMapWindow(dpy, c->win);
+	if (!HIDDEN(c))
+		XMapWindow(dpy, c->win);
 	focus(NULL);
 }

@@ -1560,7 +1843,7 @@ nexttagged(Client *c) {
 Client *
 nexttiled(Client *c)
 {
-	for (; c && (c->isfloating || !ISVISIBLE(c)); c = c->next);
+	for (; c && (c->isfloating || !ISVISIBLE(c) || HIDDEN(c)); c = c->next);
 	return c;
 }

@@ -1670,6 +1953,14 @@ pop(Client *c)
 	arrange(c->mon);
 }

+uint32_t
+prealpha(uint32_t p) {
+	uint8_t a = p >> 24u;
+	uint32_t rb = (a * (p & 0xFF00FFu)) >> 8u;
+	uint32_t g = (a * (p & 0x00FF00u)) >> 8u;
+	return (rb & 0xFF00FFu) | (g & 0x00FF00u) | (a << 24u);
+}
+
 void
 propertynotify(XEvent *e)
 {
@@ -1713,6 +2004,11 @@ propertynotify(XEvent *e)
 			if (c == c->mon->sel)
 				drawbar(c->mon);
 		}
+		if (ev->atom == netatom[NetWMIcon]) {
+			updateicon(c);
+			if (c == c->mon->sel)
+				drawbar(c->mon);
+		}
 		if (ev->atom == netatom[NetWMWindowType])
 			updatewindowtype(c);
 	}
@@ -1721,6 +2017,16 @@ propertynotify(XEvent *e)
 void
 quit(const Arg *arg)
 {
+	// fix: reloading dwm keeps all the hidden clients hidden
+	Monitor *m;
+	Client *c;
+	for (m = mons; m; m = m->next) {
+		if (m) {
+			for (c = m->stack; c; c = c->next)
+				if (c && HIDDEN(c)) showwin(c);
+		}
+	}
+
 	if(arg->i) restart = 1;
 	running = 0;
 }
@@ -2188,6 +2494,7 @@ setup(void)
 	netatom[NetSystemTrayOrientation] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION", False);
 	netatom[NetSystemTrayOrientationHorz] = XInternAtom(dpy, "_NET_SYSTEM_TRAY_ORIENTATION_HORZ", False);
 	netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
+	netatom[NetWMIcon] = XInternAtom(dpy, "_NET_WM_ICON", False);
 	netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False);
 	netatom[NetWMCheck] = XInternAtom(dpy, "_NET_SUPPORTING_WM_CHECK", False);
 	netatom[NetWMFullscreen] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
@@ -2261,6 +2568,42 @@ seturgent(Client *c, int urg)
 	XFree(wmh);
 }

+void
+show(const Arg *arg)
+{
+	if (selmon->hidsel)
+		selmon->hidsel = 0;
+	showwin(selmon->sel);
+}
+
+void
+showall(const Arg *arg)
+{
+	Client *c = NULL;
+	selmon->hidsel = 0;
+	for (c = selmon->clients; c; c = c->next) {
+		if (ISVISIBLE(c))
+			showwin(c);
+	}
+	if (!selmon->sel) {
+		for (c = selmon->clients; c && !ISVISIBLE(c); c = c->next);
+		if (c)
+			focus(c);
+	}
+	restack(selmon);
+}
+
+void
+showwin(Client *c)
+{
+	if (!c || !HIDDEN(c))
+		return;
+
+	XMapWindow(dpy, c->win);
+	setclientstate(c, NormalState);
+	arrange(c->mon);
+}
+
 void
 showhide(Client *c)
 {
@@ -2481,6 +2824,25 @@ toggleview(const Arg *arg)
 	}
 }

+void
+togglewin(const Arg *arg)
+{
+	Client *c = (Client*)arg->v;
+
+	if (!c)
+		return;
+	if (c == selmon->sel) {
+		hidewin(c);
+		focus(NULL);
+		arrange(c->mon);
+	} else {
+		if (HIDDEN(c))
+			showwin(c);
+		focus(c);
+		restack(selmon);
+	}
+}
+
 void
 unfocus(Client *c, int setfocus)
 {
@@ -2502,6 +2864,7 @@ unmanage(Client *c, int destroyed)

 	detach(c);
 	detachstack(c);
+	freeicon(c);
 	if (!destroyed) {
 		wc.border_width = c->oldbw;
 		XGrabServer(dpy); /* avoid race conditions */
@@ -2604,6 +2967,13 @@ void updatecurrentdesktop(void){
 	XChangeProperty(dpy, root, netatom[NetCurrentDesktop], XA_CARDINAL, 32, PropModeReplace, (unsigned char *)data, 1);
 }

+void
+updateicon(Client *c)
+{
+	freeicon(c);
+	c->icon = geticonprop(dpy, c->win, iconsize, &c->icw, &c->ich);
+}
+
 int
 updategeom(void)
 {