/* (C)opyright MMVI-MMVII Anselm R. Garbe <garbeam at gmail dot com>

 * See LICENSE file for license details.

 */

#include "dwm.h"

/* static */

static Client *

nexttiled(Client *c) {

	for(c = getnext(c); c && c->isfloat; c = getnext(c->next));

	return c;

}

static Bool

ismaster(Client *c) {

	Client *cl;

	unsigned int i;

	for(cl = nexttiled(clients), i = 0; cl && cl != c; cl = nexttiled(cl->next), i++);

	return i < nmaster;

}

static void

pop(Client *c) {

	detach(c);

	if(clients)

		clients->prev = c;

	c->next = clients;

	clients = c;

}

static void

swap(Client *c1, Client *c2) {

	Client tmp = *c1;

	Client *c1p = c1->prev;

	Client *c1n = c1->next;

	Client *c2p = c2->prev;

	Client *c2n = c2->next;

	*c1 = *c2;

	*c2 = tmp;

	c1->prev = c1p;

	c1->next = c1n;

	c2->prev = c2p;

	c2->next = c2n;

}

static void

togglemax(Client *c) {

	XEvent ev;

	if(c->isfixed)

		return;

	if((c->ismax = !c->ismax)) {

		c->rx = c->x; c->x = wax;

		c->ry = c->y; c->y = way;

		c->rw = c->w; c->w = waw - 2 * BORDERPX;

		c->rh = c->h; c->h = wah - 2 * BORDERPX;

	}

	else {

		c->x = c->rx;

		c->y = c->ry;

		c->w = c->rw;

		c->h = c->rh;

	}

	resize(c, True, TopLeft);

	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));

}

static Client *

topofstack() {

	Client *c;

	unsigned int i;

	for(c = nexttiled(clients), i = 0; c && i < nmaster; c = nexttiled(c->next), i++);

	return (i < nmaster) ? NULL : c;

}

/* extern */

void (*arrange)(void) = DEFMODE;

void

detach(Client *c) {

	if(c->prev)

		c->prev->next = c->next;

	if(c->next)

		c->next->prev = c->prev;

	if(c == clients)

		clients = c->next;

	c->next = c->prev = NULL;

}

void

dofloat(void) {

	Client *c;

	for(c = clients; c; c = c->next) {

		if(isvisible(c)) {

			resize(c, True, TopLeft);

		}

		else

			ban(c);

	}

	if(!sel || !isvisible(sel)) {

		for(c = stack; c && !isvisible(c); c = c->snext);

		focus(c);

	}

	restack();

}

void

dotile(void) {

	unsigned int i, n, mw, mh, tw, th;

	Client *c;

	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

		n++;

	/* window geoms */

	mw = (n > nmaster) ? (waw * master) / 1000 : waw;

	mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);

	tw = waw - mw;

	th = (n > nmaster) ? wah / (n - nmaster) : 0;

	for(i = 0, c = clients; c; c = c->next)

		if(isvisible(c)) {

			if(c->isfloat) {

				resize(c, True, TopLeft);

				continue;

			}

			c->ismax = False;

			c->x = wax;

			c->y = way;

			if(i < nmaster) {

				c->y += i * mh;

				c->w = mw - 2 * BORDERPX;

				c->h = mh - 2 * BORDERPX;

			}

			else {  /* tile window */

				c->x += mw;

				c->w = tw - 2 * BORDERPX;

				if(th > bh) {

					c->y += (i - nmaster) * th;

					c->h = th - 2 * BORDERPX;

				}

				else /* fallback if th < bh */

					c->h = wah - 2 * BORDERPX;

			}

			resize(c, False, TopLeft);

			i++;

		}

		else

			ban(c);

	if(!sel || !isvisible(sel)) {

		for(c = stack; c && !isvisible(c); c = c->snext);

		focus(c);

	}

	restack();

}

void

focusnext(Arg *arg) {

	Client *c;

	if(!sel)

		return;

	if(!(c = getnext(sel->next)))

		c = getnext(clients);

	if(c) {

		focus(c);

		restack();

	}

}

void

focusprev(Arg *arg) {

	Client *c;

	if(!sel)

		return;

	if(!(c = getprev(sel->prev))) {

		for(c = clients; c && c->next; c = c->next);

		c = getprev(c);

	}

	if(c) {

		focus(c);

		restack();

	}

}

void

incnmaster(Arg *arg) {

	if((nmaster + arg->i < 1) || (wah / (nmaster + arg->i) < bh))

		return;

	nmaster += arg->i;

	arrange();

}

Bool

isvisible(Client *c) {

	unsigned int i;

	for(i = 0; i < ntags; i++)

		if(c->tags[i] && seltag[i])

			return True;

	return False;

}

void

resizemaster(Arg *arg) {

	if(arg->i == 0)

		master = MASTER;

	else {

		if(master + arg->i > 950 || master + arg->i < 50)

			return;

		master += arg->i;

	}

	arrange();

}

void

restack(void) {

	Client *c;

	XEvent ev;

	if(!sel) {

		drawstatus();

		return;

	}

	if(sel->isfloat || arrange == dofloat) {

		XRaiseWindow(dpy, sel->win);

		XRaiseWindow(dpy, sel->twin);

	}

	if(arrange != dofloat) {

		if(!sel->isfloat) {

			XLowerWindow(dpy, sel->twin);

			XLowerWindow(dpy, sel->win);

		}

		for(c = nexttiled(clients); c; c = nexttiled(c->next)) {

			if(c == sel)

				continue;

			XLowerWindow(dpy, c->twin);

			XLowerWindow(dpy, c->win);

		}

	}

	drawall();

	XSync(dpy, False);

	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));

}

void

togglefloat(Arg *arg) {

	if (!sel || arrange == dofloat)

		return;

	sel->isfloat = !sel->isfloat;

	arrange();

}

void

togglemode(Arg *arg) {

	arrange = (arrange == dofloat) ? dotile : dofloat;

	if(sel)

		arrange();

	else

		drawstatus();

}

void

toggleview(Arg *arg) {

	unsigned int i;

	seltag[arg->i] = !seltag[arg->i];

	for(i = 0; i < ntags && !seltag[i]; i++);

	if(i == ntags)

		seltag[arg->i] = True; /* cannot toggle last view */

	arrange();

}

void

view(Arg *arg) {

	unsigned int i;

	for(i = 0; i < ntags; i++)

		seltag[i] = (arg->i == -1) ? True : False;

	if(arg->i >= 0 && arg->i < ntags)

		seltag[arg->i] = True;

	arrange();

}

void

zoom(Arg *arg) {

	unsigned int n;

	Client *c;

	if(!sel)

		return;

	if(sel->isfloat || (arrange == dofloat)) {

		togglemax(sel);

		return;

	}

	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))

		n++;

	c = sel;

	if(arrange == dofloat)

		return;

	else if(n <= nmaster)

		pop(c);

	else if(ismaster(sel)) {

		if(!(c = topofstack()))

			return;

		swap(c, sel);

		c = sel;

	}

	else

		pop(c);

	focus(c);

	arrange();

}