swm

lyt.c (9164B)

---

 /*
  * Copyright (C) Raymond Cole <rc@wolog.xyz>
  * License: GPL-3.0-or-later
  *
  * Portions of the code are derived from suckless dwm.  See file
  * LICENSE-dwm for copyright and license details of those portions.
  */
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <X11/Xlib.h>
 
 #include "swm.h"
 
 enum { W, H, X, Y };
 
 static LytNode *parse(const char **ps, LytNode *parent, int rev);
 static Client *nexttiled(Client *c);
 static void makeplans(Monitor *m, LytNode *p, int area[2]);
 static void tile(Monitor *m, LytNode *p, int area[4]);
 static void getdesc(LytNode *n, int rev, char **ps, size_t *psize);
 
 LytNode *
 parse(const char **ps, LytNode *parent, int rev)
 {
 	LytNode *lyt = NULL, *n = NULL;
 	LytNode **end = &lyt;
 	const char *s = *ps, *num;
 	char b, d;
 	int rev2;
 
 	s += strspn(s, " \t");
 	while (*s && !strchr("}])", *s)) {
 		if (!(n = malloc(sizeof(*n)))) {
 			warn("malloc:");
 			goto fail;
 		}
 		n->type = '*';
 		n->trailing = 0;
 		n->fact = -1;
 		n->next = *end;
 		*end = n;
 		num = NULL;
 		rev2 = 0;
 		switch (*s) {
 		case '*':
 			++s;
 			break;
 		case '-':
 			rev2 = 1;
 			/* FALLTHROUGH */
 		case '+':
 			if (!strchr("{[(", s[1])) {
 				num = s;
 				break;
 			}
 			++s;
 			/* FALLTHROUGH */
 		case '{':
 		case '[':
 		case '(':
 			b = *s++;
 			d = strchr("{}[]()", b)[1];
 			n->type = rev2 ? d : b;
 			if (!(n->p.chain = parse(&s, n, rev2)))
 				n->p.chain = n;
 			if (*s++ != d) {
 				warn("`%c' mismatched in layout description", b);
 				goto fail;
 			}
 			s += strspn(s, " \t");
 			if (*s == ':')
 				num = s + 1;
 			break;
 		default:
 			num = s;
 			break;
 		}
 		if (num) {
 			errno = 0;
 			n->fact = strtof(num, (char **)&s);
 			if (errno || n->fact < 0 || n->fact > 1) {
 				if (errno) {
 					s = num + 1;
 					s += strcspn(s, " \t*+-{}[]()");
 				}
 				warn("invalid value `%.*s' in layout description",
 				     (int)(s - num), num);
 				goto fail;
 			}
 		}
 		s += strspn(s, " \t");
 		if (!rev)
 			end = &n->next;
 	}
 	if (lyt) {
 		for (n = lyt; n->next; n = n->next)
 			n->ending = n->loaded = 0;
 		n->next = parent;
 		n->ending = 1;
 	}
 	*ps = s;
 	return lyt;
 fail:
 	lytfree(lyt);
 	return NULL;
 }
 
 LytNode *
 lytparse(const char *s)
 {
 	LytNode *r = parse(&s, NULL, 0);
 
 	if (*s) {
 		warn("trailing characters `%s' in layout description", s);
 		lytfree(r);
 		r = NULL;
 	}
 	return r;
 }
 
 void
 lytfree(LytNode *lyt)
 {
 	LytNode *n = lyt, *nx;
 
 	if (!n)
 		return;
 	do {
 		if (n->type != '*' && n->p.chain != n)
 			lytfree(n->p.chain);
 		nx = n->ending ? NULL : n->next;
 		free(n);
 		n = nx;
 	} while (n);
 }
 
 Client *
 nexttiled(Client *c)
 {
 	for (; c; c = c->next)
 		if (ISVISIBLE(c) && !c->isfullscreen && !c->isfloating)
 			return c;
 	return NULL;
 }
 
 void
 makeplans(Monitor *m, LytNode *p, int area[2])
 {
 	int w, h, u, v, t;
 	LytNode *n, *o;
 	Client *c;
 	int rect[2];
 
 	switch (p->type) {
 	case '*':
 		if (!RESIZEHINTS)
 			return;
 		c = p->p.client;
 		u = 2 * borderw;
 		v = 2 * borderw;
 		if (!m->nogaps) {
 			u += m->gapih;
 			v += m->gapiv;
 		}
 		w = c->maxw;
 		h = c->maxh;
 		c->maxw = area[W] - u;
 		c->maxh = area[H] - v;
 		if (!m->nogaps) {
 			c->maxw += MIN(m->gapih, m->gapoh);
 			c->maxh += MIN(m->gapiv, m->gapov);
 		}
 		if (w && w < c->maxw)
 			c->maxw = w;
 		if (h && h < c->maxh)
 			c->maxh = h;
 		p->plan[W] -= u;
 		p->plan[H] -= v;
 		if (p->plan[W] > 0 && p->plan[H] > 0)
 			applysizehints(c, &p->plan[W], &p->plan[H]);
 		p->plan[W] += u;
 		p->plan[H] += v;
 		c->maxw = w;
 		c->maxh = h;
 		return;
 	case '{':
 	case '}':
 		w = W, h = H;
 		break;
 	case '[':
 	case ']':
 		w = H, h = W;
 		break;
 	default:
 		w = h = 0;
 		for (n = p->p.chain; n != p && n->loaded; n = n->next) {
 			if (n->fact < 0) {
 				n->plan[W] = p->plan[W];
 				n->plan[H] = p->plan[H];
 			} else {
 				n->plan[W] = p->plan[W] * n->fact;
 				n->plan[H] = p->plan[H] * n->fact;
 			}
 			makeplans(m, n, area);
 			if (w < n->plan[W])
 				w = n->plan[W];
 			if (h < n->plan[H])
 				h = n->plan[H];
 		}
 		p->plan[W] = w;
 		p->plan[H] = h;
 		return;
 	}
 	u = p->plan[w];
 	v = 0;
 	for (n = p->p.chain; n != p && n->loaded; n = n->next) {
 		if (n->fact < 0) {
 			++v;
 		} else {
 			n->plan[w] = p->plan[w] * n->fact;
 			if (n->plan[w] > u)
 				n->plan[w] = u;
 			u -= n->plan[w];
 		}
 		n->plan[h] = p->plan[h];
 	}
 	if (v) {
 		for (n = p->p.chain; v; n = n->next) {
 			if (n->fact < 0) {
 				u -= n->plan[w] = (u + v - 1) / v;
 				--v;
 			}
 		}
 	} else {
 		p->p.chain->plan[w] += u;
 	}
 	p->plan[w] = p->plan[h] = 0;
 	for (n = p->p.chain; n != p && n->loaded; n = n->next) {
 		rect[w] = area[w] - p->plan[w];
 		rect[h] = area[h];
 		t = n->plan[w];
 		makeplans(m, n, rect);
 		p->plan[w] += n->plan[w];
 		if ((u = t - n->plan[w])) {
 			v = 0;
 			for (o = n->next; o != p && o->loaded; o = o->next)
 				v += o->plan[w];
 			for (o = n->next; v > 0; o = o->next) {
 				t = u < 0 ? (u * o->plan[w] - v + 1) / v
 				          : (u * o->plan[w] + v - 1) / v;
 				u -= t;
 				v -= o->plan[w];
 				if ((o->plan[w] += t) < 0)
 					o->plan[w] = 0;
 			}
 		}
 		if (p->plan[h] < n->plan[h])
 			p->plan[h] = n->plan[h];
 	}
 }
 
 void
 tile(Monitor *m, LytNode *p, int area[4])
 {
 	int x, y, w, h, t, rev;
 	int gih, giv;
 	LytNode *n;
 	Client *c;
 	int rect[4];
 
 	if (m->nogaps) {
 		gih = giv = 0;
 	} else {
 		gih = m->gapih;
 		giv = m->gapiv;
 	}
 	switch (p->type) {
 	case '*':
 		c = p->p.client;
 		w = p->plan[W];
 		h = p->plan[H];
 		x = area[X] + (area[W] - w) / 2;
 		y = area[Y] + (area[H] - h) / 2;
 		w -= 2 * borderw + gih;
 		h -= 2 * borderw + giv;
 		x += gih / 2;
 		y += giv / 2;
 		if (w <= 0)
 			w = 1;
 		if (h <= 0)
 			h = 1;
 		if ((t = c->w != w || c->h != h)) {
 			c->w = w;
 			c->h = h;
 		}
 		if (t || c->x != x || c->y != y) {
 			c->x = x;
 			c->y = y;
 			configure(c, t);
 		}
 		return;
 	case '{':
 	case '}':
 		w = W, h = H;
 		x = X, y = Y;
 		rev = p->type == '}';
 		break;
 	case '[':
 	case ']':
 		w = H, h = W;
 		x = Y, y = X;
 		rev = p->type == ']';
 		break;
 	default:
 		for (n = p->p.chain; n != p && n->loaded; n = n->next)
 			tile(m, n, area);
 		return;
 	}
 	t = (area[w] - p->plan[w]) / 2;
 	rect[x] = rev ? area[x] + area[w] - t : area[x] + t;
 	rect[y] = area[y];
 	rect[h] = area[h];
 	for (n = p->p.chain; n != p && n->loaded; n = n->next) {
 		rect[w] = n->plan[w];
 		if (rev)
 			rect[x] -= rect[w];
 		tile(m, n, rect);
 		if (!rev)
 			rect[x] += rect[w];
 	}
 }
 
 void
 lyttile(Monitor *m)
 {
 	int u, v;
 	int area[4];
 	LytNode *n, *t;
 	Client *c;
 	static LytNode r = {
 		.type = '{',
 		.ending = 1,
 		.trailing = 0,
 		.fact = -1,
 		.next = NULL,
 	};
 
 	if (!(n = m->lyt) || !(c = nexttiled(m->clients)))
 		return;
 	do {
 		n->loaded = !!c;
 		t = n;
 		if (n->type != '*' && n->p.chain != n) {
 			n = n->p.chain;
 		} else {
 			if (n->type == '*') {
 				n->p.client = c;
 				if (c)
 					c = nexttiled(c->next);
 			}
 			while (n->ending && (n = n->next))
 				;
 			if (!n)
 				break;
 			n = n->next;
 		}
 	} while (n);
 	if (c) {
 		do {
 			if (!(n = malloc(sizeof(*n)))) {
 				warn("some windows won't be tiled:");
 				break;
 			}
 			n->type = '*';
 			n->ending = 1;
 			n->loaded = 1;
 			n->trailing = 1;
 			n->fact = -1;
 			n->p.client = c;
 			if (t->type == '*') {
 				n->next = t->next;
 				t->ending = 0;
 				t->next = n;
 			} else {
 				n->next = t;
 				t->p.chain = n;
 			}
 			t = n;
 		} while ((c = nexttiled(c->next)));
 	}
 	if (m->nogaps) {
 		u = v = 0;
 	} else {
 		u = 2 * m->gapoh - m->gapih;
 		v = 2 * m->gapov - m->gapiv;
 	}
 	if (m->lyt->type != '*' && m->lyt->ending) {
 		n = m->lyt;
 	} else {
 		n = &r;
 		n->p.chain = m->lyt;
 		for (t = m->lyt; !t->ending; t = t->next)
 			;
 		t->next = n;
 	}
 	n->plan[W] = area[W] = m->w  - u;
 	n->plan[H] = area[H] = WH(m) - v;
 	area[X] = m->x  + u / 2;
 	area[Y] = WY(m) + v / 2;
 	makeplans(m, n, area);
 	tile(m, n, area);
 	if (n == &r) {
 		n->p.chain = NULL;
 		for (t = m->lyt; !t->ending; t = t->next)
 			;
 		t->next = NULL;
 	}
 }
 
 void
 getdesc(LytNode *n, int rev, char **ps, size_t *psize)
 {
 	char b, d;
 	int t;
 
 	if (rev && !n->ending && !n->next->trailing) {
 		getdesc(n->next, 1, ps, psize);
 		if (*psize < 1)
 			return;
 		*(*ps)++ = ' ';
 		--*psize;
 	}
 	if (n->type != '*') {
 		if (strchr("{}", n->type))
 			b = '{', d = '}';
 		else if (strchr("[]", n->type))
 			b = '[', d = ']';
 		else
 			b = '(', d = ')';
 		if (n->type == d) {
 			if (*psize < 1)
 				return;
 			*(*ps)++ = '-';
 			++*psize;
 		}
 		if (*psize < 1)
 			return;
 		*(*ps)++ = b;
 		--*psize;
 		if (n->p.chain != n && !n->p.chain->trailing)
 			getdesc(n->p.chain, n->type == d, ps, psize);
 		if (*psize < 1)
 			return;
 		*(*ps)++ = d;
 		--*psize;
 		if (n->fact >= 0) {
 			if (*psize < 1)
 				return;
 			*(*ps)++ = ':';
 			--*psize;
 		}
 	} else if (n->fact < 0) {
 		if (*psize < 1)
 			return;
 		*(*ps)++ = '*';
 		--*psize;
 	}
 	if (n->fact >= 0) {
 		if (*psize < 3)
 			return;
 		snprintf(*ps, *psize, ".%d", (int)(n->fact * 100 + .5));
 		*ps += (t = strlen(*ps));
 		*psize -= t;
 	}
 	if (!rev && !n->ending && !n->next->trailing) {
 		if (*psize < 1)
 			return;
 		*(*ps)++ = ' ';
 		--*psize;
 		getdesc(n->next, 0, ps, psize);
 	}
 }
 
 void
 updatelytdesc(Monitor *m)
 {
 	char *buf = m->lytdesc;
 	size_t size = sizeof(m->lytdesc);
 
 	if (!m->lyt) {
 		*buf = '\0';
 		return;
 	}
 	getdesc(m->lyt, 0, &buf, &size);
 	if (!size)
 		--buf;
 	*buf = '\0';
 }