/* See LICENSE file for copyright and license details.

 *

 * dynamic window manager is designed like any other X client as well. It is

 * driven through handling X events. In contrast to other X clients, a window

 * manager selects for SubstructureRedirectMask on the root window, to receive

 * events about window (dis-)appearance.  Only one X connection at a time is

 * allowed to select for this event mask.

 *

 * Calls to fetch an X event from the event queue are blocking.  Due reading

 * status text from standard input, a select()-driven main loop has been

 * implemented which selects for reads on the X connection and STDIN_FILENO to

 * handle all data smoothly. The event handlers of dwm are organized in an

 * array which is accessed whenever a new event has been fetched. This allows

 * event dispatching in O(1) time.

 *

 * Each child of the root window is called a client, except windows which have

 * set the override_redirect flag.  Clients are organized in a global

 * doubly-linked client list, the focus history is remembered through a global

 * stack list. Each client contains an array of Bools of the same size as the

 * global tags array to indicate the tags of a client.  For each client dwm

 * creates a small title window, which is resized whenever the (_NET_)WM_NAME

 * properties are updated or the client is moved/resized.

 *

 * Keys and tagging rules are organized as arrays and defined in config.h.

 *

 * To understand everything else, start reading main().

 */

#include <errno.h>

#include <locale.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/select.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <regex.h>

#include <X11/cursorfont.h>

#include <X11/keysym.h>

#include <X11/Xatom.h>

#include <X11/Xproto.h>

#include <X11/Xutil.h>

/* macros */

#define BUTTONMASK		(ButtonPressMask | ButtonReleaseMask)

#define CLEANMASK(mask)		(mask & ~(numlockmask | LockMask))

#define MOUSEMASK		(BUTTONMASK | PointerMotionMask)

void

applyrules(Client *c) {

	static char buf[512];

	unsigned int i, j;

	regmatch_t tmp;

	Bool matched = False;

	XClassHint ch = { 0 };

	/* rule matching */

	XGetClassHint(dpy, c->win, &ch);

	snprintf(buf, sizeof buf, "%s:%s:%s",

			ch.res_class ? ch.res_class : "",

			ch.res_name ? ch.res_name : "", c->name);

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

		if(regs[i].propregex && !regexec(regs[i].propregex, buf, 1, &tmp, 0)) {

			c->isfloating = rules[i].isfloating;

			for(j = 0; regs[i].tagregex && j < ntags; j++) {

				if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) {

					matched = True;

					c->tags[j] = True;

				}

			}

		}

	if(ch.res_class)

		XFree(ch.res_class);

	if(ch.res_name)

		XFree(ch.res_name);

	if(!matched)

		memcpy(c->tags, seltags, sizeof seltags);

}

void

arrange(void) {

	Client *c;

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

		if(isvisible(c))

			unban(c);

		else

			ban(c);

	layouts[ltidx].arrange();

	focus(NULL);

	restack();

}

void

attach(Client *c) {

	if(clients)

		clients->prev = c;

	c->next = clients;

	clients = c;

}

void

attachstack(Client *c) {

	c->snext = stack;

	stack = c;

}

void

ban(Client *c) {

	if(c->isbanned)

		return;

	XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);

	c->isbanned = True;

}

void

buttonpress(XEvent *e) {

	unsigned int i, x;

	Client *c;

	XButtonPressedEvent *ev = &e->xbutton;

	if(barwin == ev->window) {

		x = 0;

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

			x += textw(tags[i]);

			if(ev->x < x) {

				if(ev->button == Button1) {

					if(ev->state & MODKEY)

						tag(tags[i]);

					else

						view(tags[i]);

				}

				else if(ev->button == Button3) {

					if(ev->state & MODKEY)

						toggletag(tags[i]);

					else

						toggleview(tags[i]);

				}

				return;

			}

		}

		if((ev->x < x + blw) && ev->button == Button1)

			setlayout(NULL);

	}

	else if((c = getclient(ev->window))) {

		focus(c);

		if(CLEANMASK(ev->state) != MODKEY)

			return;

		if(ev->button == Button1) {

			if(isarrange(floating) || c->isfloating)

				restack();

			else

				togglefloating(NULL);

			movemouse(c);

		}

		else if(ev->button == Button2) {

			if(ISTILE && !c->isfixed && c->isfloating)

				togglefloating(NULL);

			else

				zoom(NULL);

		}

		else if(ev->button == Button3 && !c->isfixed) {

			if(isarrange(floating) || c->isfloating)

				restack();

			else

				togglefloating(NULL);

			resizemouse(c);

		}

	}

}

void

checkotherwm(void) {

	otherwm = False;

	XSetErrorHandler(xerrorstart);

	/* this causes an error if some other window manager is running */

	XSelectInput(dpy, root, SubstructureRedirectMask);

	XSync(dpy, False);

	if(otherwm)

		eprint("dwm: another window manager is already running\n");

	XSync(dpy, False);

	XSetErrorHandler(NULL);

	xerrorxlib = XSetErrorHandler(xerror);

	XSync(dpy, False);

}

void

cleanup(void) {

	close(STDIN_FILENO);

	while(stack) {

		unban(stack);

		unmanage(stack);

	}

	if(dc.font.set)

		XFreeFontSet(dpy, dc.font.set);

	else

		XFreeFont(dpy, dc.font.xfont);

	XUngrabKey(dpy, AnyKey, AnyModifier, root);

	XFreePixmap(dpy, dc.drawable);

	XFreeGC(dpy, dc.gc);

	XDestroyWindow(dpy, barwin);

	XFreeCursor(dpy, cursor[CurNormal]);

	XFreeCursor(dpy, cursor[CurResize]);

	XFreeCursor(dpy, cursor[CurMove]);

	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);

	XSync(dpy, False);

}

void

compileregs(void) {

	unsigned int i;

	regex_t *reg;

	if(regs)

		return;

	nrules = sizeof rules / sizeof rules[0];

	regs = emallocz(nrules * sizeof(Regs));

	for(i = 0; i < nrules; i++) {

		if(rules[i].prop) {

			reg = emallocz(sizeof(regex_t));

			if(regcomp(reg, rules[i].prop, REG_EXTENDED))

				free(reg);

			else

				regs[i].propregex = reg;

		}

		if(rules[i].tags) {

			reg = emallocz(sizeof(regex_t));

			if(regcomp(reg, rules[i].tags, REG_EXTENDED))

				free(reg);

			else

				regs[i].tagregex = reg;

		}

	}

}

void

configure(Client *c) {

	XConfigureEvent ce;

	ce.type = ConfigureNotify;

	ce.display = dpy;

	ce.event = c->win;

	ce.window = c->win;

	ce.x = c->x;

	ce.y = c->y;

	ce.width = c->w;

	ce.height = c->h;

	ce.border_width = c->border;

	ce.above = None;

	ce.override_redirect = False;

	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *)&ce);

}

void

configurenotify(XEvent *e) {

	XConfigureEvent *ev = &e->xconfigure;

	if(ev->window == root && (ev->width != sw || ev->height != sh)) {

		sw = ev->width;

		sh = ev->height;

		XFreePixmap(dpy, dc.drawable);

		dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));

		XResizeWindow(dpy, barwin, sw, bh);

		updatebarpos();

		arrange();

	}

}

void

configurerequest(XEvent *e) {

	Client *c;

	XConfigureRequestEvent *ev = &e->xconfigurerequest;

	XWindowChanges wc;

	if((c = getclient(ev->window))) {

		c->ismax = False;

		if(ev->value_mask & CWBorderWidth)

			c->border = ev->border_width;

		if(c->isfixed || c->isfloating || isarrange(floating)) {

			if(ev->value_mask & CWX)

				c->x = ev->x;

			if(ev->value_mask & CWY)

				c->y = ev->y;

			if(ev->value_mask & CWWidth)

				c->w = ev->width;

			if(ev->value_mask & CWHeight)

				c->h = ev->height;

			if((c->x + c->w) > sw && c->isfloating)

				c->x = sw / 2 - c->w / 2; /* center in x direction */

			if((c->y + c->h) > sh && c->isfloating)

				c->y = sh / 2 - c->h / 2; /* center in y direction */

			if((ev->value_mask & (CWX | CWY))

			&& !(ev->value_mask & (CWWidth | CWHeight)))

				configure(c);

			if(isvisible(c))

				XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h);

		}

		else

			configure(c);

	}

	else {

		wc.x = ev->x;

		wc.y = ev->y;

		wc.width = ev->width;

		wc.height = ev->height;

		wc.border_width = ev->border_width;

		wc.sibling = ev->above;

		wc.stack_mode = ev->detail;

		XConfigureWindow(dpy, ev->window, ev->value_mask, &wc);

	}

	XSync(dpy, False);

}

void

destroynotify(XEvent *e) {

	Client *c;

	XDestroyWindowEvent *ev = &e->xdestroywindow;

	if((c = getclient(ev->window)))

		unmanage(c);

}

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

detachstack(Client *c) {

	Client **tc;

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