git.stevedylan.dev

implemented setlayout in the way proposed on the ml, split tile() into two functions, a third will follow soon c9170189

Anselm R Garbe · 2008-03-06 18:53 2 file(s) · +109 −103

config.def.h +17 −17

/* bar position */
#define BX sx
#define BY sy
#define BW MW
#define BW sw

/* window area */
#define WX 0
#define WY bh
#define WW sw
#define WH sh
#define WH sh - bh

/* master area */
#define MX sx
#define MY sy + bh
#define MX WX
#define MY WY
#define MW ((int)(((float)sw) * 0.6))
#define MH sh - bh
#define MH WH

/* tile area, might be on a different screen */
#define TX sx + MW
#define TY sy
#define TW sw - MW
#define TH sh
#define TX MX + MW
#define TY WY
#define TW WW - MW
#define TH WH

/* monocle area, might be restricted to a specific screen */
#define MOX sx
#define MOY MY
#define MOW sw
#define MOH MH
#define MOX WX
#define MOY WY
#define MOW WW
#define MOH WH

/* tagging */
const char tags[][MAXTAGLEN] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };

#define SNAP			32	/* snap pixel */

Layout layouts[] = {
	/* symbol		function */
	{ "[]=",		tile }, /* first entry is default */
	{ "><>",		floating },
	{ "[M]",		monocle },
	/* symbol		function	isfloating */
	{ "[]=",		tile,		False }, /* first entry is default */
	{ "><>",		floating	True },
	{ "[M]",		monocle		True },
};

/* key definitions */

dwm.c +92 −86

/**
 * TODO
 * - treat monocle as floating layout, actually otherwise certain monocled windows don't get raised
 * - use WX, WY, WW, WH for window snapping/resizing/mouse
 * - MOX, MOY, MOW, MOH should only be used in the case of monocle layout and of n==1 in tiled
 * - simplify tile()
 * - allow for vstack
 */
/* See LICENSE file for copyright and license details.

struct Client {
	char name[256];
	int x, y, w, h;
	int rx, ry, rw, rh;
	int basew, baseh, incw, inch, maxw, maxh, minw, minh;
	int minax, maxax, minay, maxay;
	long flags;

typedef struct {
	const char *symbol;
	void (*arrange)(void);
	Bool isfloating;
} Layout;

typedef struct {

unsigned int textnw(const char *text, unsigned int len);
unsigned int textw(const char *text);
void tile(void);
unsigned int tilemaster(void);
void tilevstack(unsigned int n);
void togglefloating(const char *arg);
void toggletag(const char *arg);
void toggleview(const char *arg);

	[UnmapNotify] = unmapnotify
};
Atom wmatom[WMLast], netatom[NetLast];
Bool dozoom = True;
Bool otherwm, readin;
Bool running = True;
Bool *prevtags;

ban(Client *c) {
	if(c->isbanned)
		return;
	XMoveWindow(dpy, c->win, c->x + 3 * sw, c->y);
	XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
	c->isbanned = True;
}


	if((c = getclient(ev->window))) {
		if(ev->value_mask & CWBorderWidth)
			c->border = ev->border_width;
		if(c->isfixed || c->isfloating || (floating == lt->arrange)) {
		if(c->isfixed || c->isfloating || lt->isfloating) {
			if(ev->value_mask & CWX)
				c->x = sx + ev->x;
			if(ev->value_mask & CWY)

floating(void) { /* default floating layout */
	Client *c;

	dozoom = False;
	for(c = clients; c; c = c->next)
		if(isvisible(c))
			resize(c, c->x, c->y, c->w, c->h, True);

	if(sel && sel != c) {
		grabbuttons(sel, False);
		XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);
		if(lt->arrange == monocle)
			resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);
	}
	if(c) {
		detachstack(c);
		attachstack(c);
		grabbuttons(c, True);
		if(lt->arrange == monocle) {
			if(sel != c) {
				c->rx = c->x;
				c->ry = c->y;
				c->rw = c->w;
				c->rh = c->h;
			}
			resize(c, MOX, MOY, MOW, MOH, RESIZEHINTS);
		}
	}
	sel = c;
	if(c) {

	c->tags = emallocz(TAGSZ);
	c->win = w;

	c->x = c->rx = wa->x + sx;
	c->y = c->ry = wa->y + sy;
	c->w = c->rw = wa->width;
	c->h = c->rh = wa->height;
	/* geometry */
	c->x = wa->x;
	c->y = wa->y;
	c->w = wa->width;
	c->h = wa->height;
	c->oldborder = wa->border_width;

	if(c->w == sw && c->h == sh) {
		c->x = sx;
		c->y = sy;
		c->border = wa->border_width;
	}
	else {
		if(c->x + c->w + 2 * c->border > sx + sw)
			c->x = sx + sw - c->w - 2 * c->border;
		if(c->y + c->h + 2 * c->border > sy + sh)
			c->y = sy + sh - c->h - 2 * c->border;
		if(c->x < sx)
			c->x = sx;
		if(c->y < sy)
			c->y = sy;
		if(c->x + c->w + 2 * c->border > WX + WW)
			c->x = WX + WW - c->w - 2 * c->border;
		if(c->y + c->h + 2 * c->border > WY + WH)
			c->y = WY + WH - c->h - 2 * c->border;
		if(c->x < WX)
			c->x = WX;
		if(c->y < WY)
			c->y = WY;
		c->border = BORDERPX;
	}

	wc.border_width = c->border;
	XConfigureWindow(dpy, w, CWBorderWidth, &wc);
	XSetWindowBorder(dpy, w, dc.norm[ColBorder]);

}

void
monocle(void) {
	dozoom = False;
monocle(void) { 
	Client *c;

	for(c = clients; c; c = c->next)
		if(isvisible(c))
			resize(c, MOX, MOY, MOW, MOH, RESIZEHINTS);
}

void

			XSync(dpy, False);
			nx = ocx + (ev.xmotion.x - x1);
			ny = ocy + (ev.xmotion.y - y1);
			if(abs(sx - nx) < SNAP)
				nx = sx;
			else if(abs((sx + sw) - (nx + c->w + 2 * c->border)) < SNAP)
				nx = sx + sw - c->w - 2 * c->border;
			if(abs(sy - ny) < SNAP)
				ny = sy;
			else if(abs((sy + sh) - (ny + c->h + 2 * c->border)) < SNAP)
				ny = sy + sh - c->h - 2 * c->border;
			if(!c->isfloating && (lt->arrange != floating) && (abs(nx - c->x) > SNAP || abs(ny - c->y) > SNAP))
			if(abs(WX - nx) < SNAP)
				nx = WX;
			else if(abs((WX + WW) - (nx + c->w + 2 * c->border)) < SNAP)
				nx = WX + WW - c->w - 2 * c->border;
			if(abs(WY - ny) < SNAP)
				ny = WY;
			else if(abs((WY + WH) - (ny + c->h + 2 * c->border)) < SNAP)
				ny = WY + WH - c->h - 2 * c->border;
			if(!c->isfloating && !lt->isfloating && (abs(nx - c->x) > SNAP || abs(ny - c->y) > SNAP))
				togglefloating(NULL);
			if((lt->arrange == floating) || c->isfloating)
			if((lt->isfloating) || c->isfloating)
				resize(c, nx, ny, c->w, c->h, False);
			break;
		}

				nw = 1;
			if((nh = ev.xmotion.y - ocy - 2 * c->border + 1) <= 0)
				nh = 1;
			if(!c->isfloating && (lt->arrange != floating) && (abs(nw - c->w) > SNAP || abs(nh - c->h) > SNAP))
			if(!c->isfloating && !lt->isfloating && (abs(nw - c->w) > SNAP || abs(nh - c->h) > SNAP))
				togglefloating(NULL);
			if((lt->arrange == floating) || c->isfloating)
			if((lt->isfloating) || c->isfloating)
				resize(c, c->x, c->y, nw, nh, True);
			break;
		}

	drawbar();
	if(!sel)
		return;
	if(sel->isfloating || (lt->arrange == floating))
	if(sel->isfloating || lt->isfloating)
		XRaiseWindow(dpy, sel->win);
	if(lt->arrange != floating) {
	if(!lt->isfloating) {
		wc.stack_mode = Below;
		wc.sibling = barwin;
		if(!sel->isfloating) {


void
setlayout(const char *arg) {
	static Layout *revert = 0;
	unsigned int i;

	if(!arg)

			break;
	if(i == LENGTH(layouts))
		return;
	lt = &layouts[i];
	if(revert && &layouts[i] == lt)
		lt = revert;
	else {
		revert = lt;
		lt = &layouts[i];
	}
	if(sel)
		arrange();
	else

}

void
tile(void) {
	unsigned int i, n, nx, ny, nw, nh, mw, th;
tileresize(Client *c, int x, int y, int w, int h) {
	resize(c, x, y, w, h, RESIZEHINTS);
	if((RESIZEHINTS) && ((c->h < bh) || (c->h > h) || (c->w < bh) || (c->w > w)))
		/* client doesn't accept size constraints */
		resize(c, x, y, w, h, False);
}

unsigned int
tilemaster(void) {
	unsigned int n;
	Client *c, *mc;

	dozoom = True;
	nx = MX;
	ny = MY;
	nw = 0;
	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
	for(n = 0, mc = c = nexttiled(clients); c; c = nexttiled(c->next))
		n++;
	if(n == 0)
		return 0;
	if(n == 1)
		tileresize(mc, MOX, MOY, (MOW) - 2 * mc->border, (MOH) - 2 * mc->border);
	else
		tileresize(mc, MX, MY, (MW) - 2 * mc->border, (MH) - 2 * mc->border);
	return n - 1;
}

	/* window geoms */
	mw = (n == 1) ? MOW : MW;
	th = (n > 1) ? TH / (n - 1) : 0;
	if(n > 1 && th < bh)
		th = TH;
void
tilevstack(unsigned int n) {
	int i, y, h;
	Client *c;

	if(n == 0)
		return;

	y = TY;
	h = (TH) / n;
	if(h < bh)
		h = TH;

	for(i = 0, c = mc = nexttiled(clients); c; c = nexttiled(c->next)) {
		if(i == 0) { /* master */
			nw = mw - 2 * c->border;
			nh = MH - 2 * c->border;
		}
		else {  /* tile window */
			if(i == 1) {
				ny = TY;
				nx = TX;
				nw = TW - 2 * c->border;
			}
			if(i + 1 == n) /* remainder */
				nh = (TY + TH) - ny - 2 * c->border;
	for(i = 0, c = nexttiled(clients); c; c = nexttiled(c->next), i++)
		if(i > 0) {
			if(i > 1 && i == n) /* remainder */
				tileresize(c, TX, y, (TW) - 2 * c->border,
				              ((TY) + (TH)) - y - 2 * c->border);
			else
				nh = th - 2 * c->border;
				tileresize(c, TX, y, (TW) - 2 * c->border,
				              h - 2 * c->border);
			if(h != TH)
				y = c->y + c->h + 2 * c->border;
		}
		resize(c, nx, ny, nw, nh, RESIZEHINTS);
		if((RESIZEHINTS) && ((c->h < bh) || (c->h > nh) || (c->w < bh) || (c->w > nw)))
			/* client doesn't accept size constraints */
			resize(c, nx, ny, nw, nh, False);
		if(n > 1 && th != TH)
			ny = c->y + c->h + 2 * c->border;
		i++;
	}
}

void
tile(void) {
	tilevstack(tilemaster());
}

void

zoom(const char *arg) {
	Client *c = sel;

	if(!sel || !dozoom || sel->isfloating)
	if(!sel || lt->isfloating || sel->isfloating)
		return;
	if(c == nexttiled(clients))
		if(!(c = nexttiled(c->next)))

13	13		/* bar position */
14	14		#define BX sx
15	15		#define BY sy
16		-	#define BW MW
	16	+	#define BW sw
17	17
18	18		/* window area */
19	19		#define WX 0
20	20		#define WY bh
21	21		#define WW sw
22		-	#define WH sh
	22	+	#define WH sh - bh
23	23
24	24		/* master area */
25		-	#define MX sx
26		-	#define MY sy + bh
	25	+	#define MX WX
	26	+	#define MY WY
27	27		#define MW ((int)(((float)sw) * 0.6))
28		-	#define MH sh - bh
	28	+	#define MH WH
29	29
30	30		/* tile area, might be on a different screen */
31		-	#define TX sx + MW
32		-	#define TY sy
33		-	#define TW sw - MW
34		-	#define TH sh
	31	+	#define TX MX + MW
	32	+	#define TY WY
	33	+	#define TW WW - MW
	34	+	#define TH WH
35	35
36	36		/* monocle area, might be restricted to a specific screen */
37		-	#define MOX sx
38		-	#define MOY MY
39		-	#define MOW sw
40		-	#define MOH MH
	37	+	#define MOX WX
	38	+	#define MOY WY
	39	+	#define MOW WW
	40	+	#define MOH WH
41	41
42	42		/* tagging */
43	43		const char tags[][MAXTAGLEN] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };

55	55		#define SNAP 32 /* snap pixel */
56	56
57	57		Layout layouts[] = {
58		-	/* symbol function */
59		-	{ "[]=", tile }, /* first entry is default */
60		-	{ "><>", floating },
61		-	{ "[M]", monocle },
	58	+	/* symbol function isfloating */
	59	+	{ "[]=", tile, False }, /* first entry is default */
	60	+	{ "><>", floating True },
	61	+	{ "[M]", monocle True },
62	62		};
63	63
64	64		/* key definitions */

1	1		/**
2		-	* TODO
3		-	* - treat monocle as floating layout, actually otherwise certain monocled windows don't get raised
4		-	* - use WX, WY, WW, WH for window snapping/resizing/mouse
5		-	* - MOX, MOY, MOW, MOH should only be used in the case of monocle layout and of n==1 in tiled
6		-	* - simplify tile()
7	2		* - allow for vstack
8	3		*/
9	4		/* See LICENSE file for copyright and license details.

67	62		struct Client {
68	63		char name[256];
69	64		int x, y, w, h;
70		-	int rx, ry, rw, rh;
71	65		int basew, baseh, incw, inch, maxw, maxh, minw, minh;
72	66		int minax, maxax, minay, maxay;
73	67		long flags;

105	99		typedef struct {
106	100		const char *symbol;
107	101		void (*arrange)(void);
	102	+	Bool isfloating;
108	103		} Layout;
109	104
110	105		typedef struct {

176	171		unsigned int textnw(const char *text, unsigned int len);
177	172		unsigned int textw(const char *text);
178	173		void tile(void);
	174	+	unsigned int tilemaster(void);
	175	+	void tilevstack(unsigned int n);
179	176		void togglefloating(const char *arg);
180	177		void toggletag(const char *arg);
181	178		void toggleview(const char *arg);

213	210		[UnmapNotify] = unmapnotify
214	211		};
215	212		Atom wmatom[WMLast], netatom[NetLast];
216		-	Bool dozoom = True;
217	213		Bool otherwm, readin;
218	214		Bool running = True;
219	215		Bool *prevtags;

297	293		ban(Client *c) {
298	294		if(c->isbanned)
299	295		return;
300		-	XMoveWindow(dpy, c->win, c->x + 3 * sw, c->y);
	296	+	XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
301	297		c->isbanned = True;
302	298		}
303	299

428	424		if((c = getclient(ev->window))) {
429	425		if(ev->value_mask & CWBorderWidth)
430	426		c->border = ev->border_width;
431		-	if(c->isfixed \|\| c->isfloating \|\| (floating == lt->arrange)) {
	427	+	if(c->isfixed \|\| c->isfloating \|\| lt->isfloating) {
432	428		if(ev->value_mask & CWX)
433	429		c->x = sx + ev->x;
434	430		if(ev->value_mask & CWY)

637	633		floating(void) { /* default floating layout */
638	634		Client *c;
639	635
640		-	dozoom = False;
641	636		for(c = clients; c; c = c->next)
642	637		if(isvisible(c))
643	638		resize(c, c->x, c->y, c->w, c->h, True);

650	645		if(sel && sel != c) {
651	646		grabbuttons(sel, False);
652	647		XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);
653		-	if(lt->arrange == monocle)
654		-	resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);
655	648		}
656	649		if(c) {
657	650		detachstack(c);
658	651		attachstack(c);
659	652		grabbuttons(c, True);
660		-	if(lt->arrange == monocle) {
661		-	if(sel != c) {
662		-	c->rx = c->x;
663		-	c->ry = c->y;
664		-	c->rw = c->w;
665		-	c->rh = c->h;
666		-	}
667		-	resize(c, MOX, MOY, MOW, MOH, RESIZEHINTS);
668		-	}
669	653		}
670	654		sel = c;
671	655		if(c) {

987	971		c->tags = emallocz(TAGSZ);
988	972		c->win = w;
989	973
990		-	c->x = c->rx = wa->x + sx;
991		-	c->y = c->ry = wa->y + sy;
992		-	c->w = c->rw = wa->width;
993		-	c->h = c->rh = wa->height;
	974	+	/* geometry */
	975	+	c->x = wa->x;
	976	+	c->y = wa->y;
	977	+	c->w = wa->width;
	978	+	c->h = wa->height;
994	979		c->oldborder = wa->border_width;
995		-
996	980		if(c->w == sw && c->h == sh) {
997	981		c->x = sx;
998	982		c->y = sy;
999	983		c->border = wa->border_width;
1000	984		}
1001	985		else {
1002		-	if(c->x + c->w + 2 * c->border > sx + sw)
1003		-	c->x = sx + sw - c->w - 2 * c->border;
1004		-	if(c->y + c->h + 2 * c->border > sy + sh)
1005		-	c->y = sy + sh - c->h - 2 * c->border;
1006		-	if(c->x < sx)
1007		-	c->x = sx;
1008		-	if(c->y < sy)
1009		-	c->y = sy;
	986	+	if(c->x + c->w + 2 * c->border > WX + WW)
	987	+	c->x = WX + WW - c->w - 2 * c->border;
	988	+	if(c->y + c->h + 2 * c->border > WY + WH)
	989	+	c->y = WY + WH - c->h - 2 * c->border;
	990	+	if(c->x < WX)
	991	+	c->x = WX;
	992	+	if(c->y < WY)
	993	+	c->y = WY;
1010	994		c->border = BORDERPX;
1011	995		}
	996	+
1012	997		wc.border_width = c->border;
1013	998		XConfigureWindow(dpy, w, CWBorderWidth, &wc);
1014	999		XSetWindowBorder(dpy, w, dc.norm[ColBorder]);

1057	1042		}
1058	1043
1059	1044		void
1060		-	monocle(void) {
1061		-	dozoom = False;
	1045	+	monocle(void) {
	1046	+	Client *c;
	1047	+
	1048	+	for(c = clients; c; c = c->next)
	1049	+	if(isvisible(c))
	1050	+	resize(c, MOX, MOY, MOW, MOH, RESIZEHINTS);
1062	1051		}
1063	1052
1064	1053		void

1089	1078		XSync(dpy, False);
1090	1079		nx = ocx + (ev.xmotion.x - x1);
1091	1080		ny = ocy + (ev.xmotion.y - y1);
1092		-	if(abs(sx - nx) < SNAP)
1093		-	nx = sx;
1094		-	else if(abs((sx + sw) - (nx + c->w + 2 * c->border)) < SNAP)
1095		-	nx = sx + sw - c->w - 2 * c->border;
1096		-	if(abs(sy - ny) < SNAP)
1097		-	ny = sy;
1098		-	else if(abs((sy + sh) - (ny + c->h + 2 * c->border)) < SNAP)
1099		-	ny = sy + sh - c->h - 2 * c->border;
1100		-	if(!c->isfloating && (lt->arrange != floating) && (abs(nx - c->x) > SNAP \|\| abs(ny - c->y) > SNAP))
	1081	+	if(abs(WX - nx) < SNAP)
	1082	+	nx = WX;
	1083	+	else if(abs((WX + WW) - (nx + c->w + 2 * c->border)) < SNAP)
	1084	+	nx = WX + WW - c->w - 2 * c->border;
	1085	+	if(abs(WY - ny) < SNAP)
	1086	+	ny = WY;
	1087	+	else if(abs((WY + WH) - (ny + c->h + 2 * c->border)) < SNAP)
	1088	+	ny = WY + WH - c->h - 2 * c->border;
	1089	+	if(!c->isfloating && !lt->isfloating && (abs(nx - c->x) > SNAP \|\| abs(ny - c->y) > SNAP))
1101	1090		togglefloating(NULL);
1102		-	if((lt->arrange == floating) \|\| c->isfloating)
	1091	+	if((lt->isfloating) \|\| c->isfloating)
1103	1092		resize(c, nx, ny, c->w, c->h, False);
1104	1093		break;
1105	1094		}

1258	1247		nw = 1;
1259	1248		if((nh = ev.xmotion.y - ocy - 2 * c->border + 1) <= 0)
1260	1249		nh = 1;
1261		-	if(!c->isfloating && (lt->arrange != floating) && (abs(nw - c->w) > SNAP \|\| abs(nh - c->h) > SNAP))
	1250	+	if(!c->isfloating && !lt->isfloating && (abs(nw - c->w) > SNAP \|\| abs(nh - c->h) > SNAP))
1262	1251		togglefloating(NULL);
1263		-	if((lt->arrange == floating) \|\| c->isfloating)
	1252	+	if((lt->isfloating) \|\| c->isfloating)
1264	1253		resize(c, c->x, c->y, nw, nh, True);
1265	1254		break;
1266	1255		}

1276	1265		drawbar();
1277	1266		if(!sel)
1278	1267		return;
1279		-	if(sel->isfloating \|\| (lt->arrange == floating))
	1268	+	if(sel->isfloating \|\| lt->isfloating)
1280	1269		XRaiseWindow(dpy, sel->win);
1281		-	if(lt->arrange != floating) {
	1270	+	if(!lt->isfloating) {
1282	1271		wc.stack_mode = Below;
1283	1272		wc.sibling = barwin;
1284	1273		if(!sel->isfloating) {

1393	1382
1394	1383		void
1395	1384		setlayout(const char *arg) {
	1385	+	static Layout *revert = 0;
1396	1386		unsigned int i;
1397	1387
1398	1388		if(!arg)

1402	1392		break;
1403	1393		if(i == LENGTH(layouts))
1404	1394		return;
1405		-	lt = &layouts[i];
	1395	+	if(revert && &layouts[i] == lt)
	1396	+	lt = revert;
	1397	+	else {
	1398	+	revert = lt;
	1399	+	lt = &layouts[i];
	1400	+	}
1406	1401		if(sel)
1407	1402		arrange();
1408	1403		else

1545	1540		}
1546	1541
1547	1542		void
1548		-	tile(void) {
1549		-	unsigned int i, n, nx, ny, nw, nh, mw, th;
	1543	+	tileresize(Client *c, int x, int y, int w, int h) {
	1544	+	resize(c, x, y, w, h, RESIZEHINTS);
	1545	+	if((RESIZEHINTS) && ((c->h < bh) \|\| (c->h > h) \|\| (c->w < bh) \|\| (c->w > w)))
	1546	+	/* client doesn't accept size constraints */
	1547	+	resize(c, x, y, w, h, False);
	1548	+	}
	1549	+
	1550	+	unsigned int
	1551	+	tilemaster(void) {
	1552	+	unsigned int n;
1550	1553		Client c, mc;
1551	1554
1552		-	dozoom = True;
1553		-	nx = MX;
1554		-	ny = MY;
1555		-	nw = 0;
1556		-	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
	1555	+	for(n = 0, mc = c = nexttiled(clients); c; c = nexttiled(c->next))
1557	1556		n++;
	1557	+	if(n == 0)
	1558	+	return 0;
	1559	+	if(n == 1)
	1560	+	tileresize(mc, MOX, MOY, (MOW) - 2 * mc->border, (MOH) - 2 * mc->border);
	1561	+	else
	1562	+	tileresize(mc, MX, MY, (MW) - 2 * mc->border, (MH) - 2 * mc->border);
	1563	+	return n - 1;
	1564	+	}
1558	1565
1559		-	/* window geoms */
1560		-	mw = (n == 1) ? MOW : MW;
1561		-	th = (n > 1) ? TH / (n - 1) : 0;
1562		-	if(n > 1 && th < bh)
1563		-	th = TH;
	1566	+	void
	1567	+	tilevstack(unsigned int n) {
	1568	+	int i, y, h;
	1569	+	Client *c;
	1570	+
	1571	+	if(n == 0)
	1572	+	return;
	1573	+
	1574	+	y = TY;
	1575	+	h = (TH) / n;
	1576	+	if(h < bh)
	1577	+	h = TH;
1564	1578
1565		-	for(i = 0, c = mc = nexttiled(clients); c; c = nexttiled(c->next)) {
1566		-	if(i == 0) { /* master */
1567		-	nw = mw - 2 * c->border;
1568		-	nh = MH - 2 * c->border;
1569		-	}
1570		-	else { /* tile window */
1571		-	if(i == 1) {
1572		-	ny = TY;
1573		-	nx = TX;
1574		-	nw = TW - 2 * c->border;
1575		-	}
1576		-	if(i + 1 == n) /* remainder */
1577		-	nh = (TY + TH) - ny - 2 * c->border;
	1579	+	for(i = 0, c = nexttiled(clients); c; c = nexttiled(c->next), i++)
	1580	+	if(i > 0) {
	1581	+	if(i > 1 && i == n) /* remainder */
	1582	+	tileresize(c, TX, y, (TW) - 2 * c->border,
	1583	+	((TY) + (TH)) - y - 2 * c->border);
1578	1584		else
1579		-	nh = th - 2 * c->border;
	1585	+	tileresize(c, TX, y, (TW) - 2 * c->border,
	1586	+	h - 2 * c->border);
	1587	+	if(h != TH)
	1588	+	y = c->y + c->h + 2 * c->border;
1580	1589		}
1581		-	resize(c, nx, ny, nw, nh, RESIZEHINTS);
1582		-	if((RESIZEHINTS) && ((c->h < bh) \|\| (c->h > nh) \|\| (c->w < bh) \|\| (c->w > nw)))
1583		-	/* client doesn't accept size constraints */
1584		-	resize(c, nx, ny, nw, nh, False);
1585		-	if(n > 1 && th != TH)
1586		-	ny = c->y + c->h + 2 * c->border;
1587		-	i++;
1588		-	}
	1590	+	}
	1591	+
	1592	+	void
	1593	+	tile(void) {
	1594	+	tilevstack(tilemaster());
1589	1595		}
1590	1596
1591	1597		void

1796	1802		zoom(const char *arg) {
1797	1803		Client *c = sel;
1798	1804
1799		-	if(!sel \|\| !dozoom \|\| sel->isfloating)
	1805	+	if(!sel \|\| lt->isfloating \|\| sel->isfloating)
1800	1806		return;
1801	1807		if(c == nexttiled(clients))
1802	1808		if(!(c = nexttiled(c->next)))