/* 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 the config.h

 * file. These arrays are kept static in event.o and tag.o respectively,

 * because no other part of dwm needs access to them.  The current layout is

 * represented by the lt pointer.

 *

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

 */

#include <errno.h>

#include <locale.h>

#include <regex.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/select.h>

#include <sys/wait.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)

/* enums */

enum { BarTop, BarBot, BarOff };			/* bar position */

enum { CurNormal, CurResize, CurMove, CurLast };	/* cursor */

enum { ColBorder, ColFG, ColBG, ColLast };		/* color */

enum { NetSupported, NetWMName, NetLast };		/* EWMH atoms */

enum { WMProtocols, WMDelete, WMName, WMState, WMLast };/* default atoms */

/* typedefs */

typedef struct Client Client;

struct Client {

	char name[256];

	int x, y, w, h;

	int rx, ry, rw, rh; /* revert geometry */

	int basew, baseh, incw, inch, maxw, maxh, minw, minh;

	int minax, maxax, minay, maxay;

	long flags; 

	unsigned int border, oldborder;

	Bool isbanned, isfixed, ismax, isfloating;

	Bool *tags;

	Client *next;

	Client *prev;

	Client *snext;

	Window win;

};

typedef struct {

	int x, y, w, h;

	unsigned long norm[ColLast];

	unsigned long sel[ColLast];

	Drawable drawable;

	GC gc;

	struct {

		int ascent;

		int descent;

		int height;

		XFontSet set;

		XFontStruct *xfont;

	} font;

} DC; /* draw context */

typedef struct {

	unsigned long mod;

	KeySym keysym;

	void (*func)(const char *arg);

	const char *arg;

} Key;

typedef struct {

	const char *symbol;

	void (*arrange)(void);

} Layout;

typedef struct {

	const char *prop;

	const char *tags;

	Bool isfloating;

} Rule;

typedef struct {

	regex_t *propregex;

	regex_t *tagregex;

} Regs;

/* functions */

static void applyrules(Client *c);

static void arrange(void);

static void attach(Client *c);

static void attachstack(Client *c);

static void ban(Client *c);

static void buttonpress(XEvent *e);

static void cleanup(void);

static void compileregs(void);

static void configure(Client *c);

static void configurenotify(XEvent *e);

static void configurerequest(XEvent *e);

static void destroynotify(XEvent *e);

static void detach(Client *c);

static void detachstack(Client *c);

static void drawbar(void);

static void drawsquare(Bool filled, Bool empty, unsigned long col[ColLast]);

static void drawtext(const char *text, unsigned long col[ColLast]);

static void *emallocz(unsigned int size);

static void enternotify(XEvent *e);

static void eprint(const char *errstr, ...);

static void expose(XEvent *e);

static void floating(void); /* default floating layout */

static void focus(Client *c);

static void focusnext(const char *arg);

static void focusprev(const char *arg);

static Client *getclient(Window w);

static long getstate(Window w);

static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);

static void grabbuttons(Client *c, Bool focused);

static unsigned int idxoftag(const char *tag);

static void initbar(void);

static unsigned long initcolor(const char *colstr);

static void initfont(const char *fontstr);

static void initlayouts(void);

static void initstyle(void);

static Bool isarrange(void (*func)());

static Bool isfloating(void);

static Bool isoccupied(unsigned int t);

static Bool isprotodel(Client *c);

static Bool isvisible(Client *c);

static void keypress(XEvent *e);

static void killclient(const char *arg);

static void leavenotify(XEvent *e);

static void manage(Window w, XWindowAttributes *wa);

static void mappingnotify(XEvent *e);

static void maprequest(XEvent *e);

static void movemouse(Client *c);

static Client *nexttiled(Client *c);

static void propertynotify(XEvent *e);

static void quit(const char *arg);

static void resize(Client *c, int x, int y, int w, int h, Bool sizehints);

static void resizemouse(Client *c);

static void restack(void);

static void scan(void);

static void setclientstate(Client *c, long state);

static void setlayout(const char *arg);

static void setmwfact(const char *arg);

static void setup(void);

static void spawn(const char *arg);

static void tag(const char *arg);

static unsigned int textnw(const char *text, unsigned int len);

static unsigned int textw(const char *text);

static void tile(void);

static void togglebar(const char *arg);

static void togglefloating(const char *arg);

static void togglemax(const char *arg);

static void toggletag(const char *arg);

static void toggleview(const char *arg);

static void unban(Client *c);

static void unmanage(Client *c);

static void unmapnotify(XEvent *e);

static void updatebarpos(void);

static void updatesizehints(Client *c);

static void updatetitle(Client *c);

static void view(const char *arg);

static int xerror(Display *dpy, XErrorEvent *ee);

static int xerrordummy(Display *dsply, XErrorEvent *ee);

static int xerrorstart(Display *dsply, XErrorEvent *ee);

static void zoom(const char *arg);

/* variables */

static char stext[256];

static double mwfact;

static int screen, sx, sy, sw, sh, wax, way, waw, wah;

static int (*xerrorxlib)(Display *, XErrorEvent *);

static unsigned int bh, bpos, ntags;

static unsigned int blw = 0;

static unsigned int ltidx = 0; /* default */

static unsigned int nlayouts = 0;

static unsigned int nrules = 0;

static unsigned int numlockmask = 0;

static void (*handler[LASTEvent]) (XEvent *) = {

	[ButtonPress] = buttonpress,

	[ConfigureRequest] = configurerequest,

	[ConfigureNotify] = configurenotify,

	[DestroyNotify] = destroynotify,

	[EnterNotify] = enternotify,

	[LeaveNotify] = leavenotify,

	[Expose] = expose,

	[KeyPress] = keypress,

	[MappingNotify] = mappingnotify,

	[MapRequest] = maprequest,

	[PropertyNotify] = propertynotify,

	[UnmapNotify] = unmapnotify

};

static Atom wmatom[WMLast], netatom[NetLast];

static Bool otherwm, readin;

static Bool running = True;

static Bool *seltags;

static Bool selscreen = True;

static Client *clients = NULL;

static Client *sel = NULL;

static Client *stack = NULL;

static Cursor cursor[CurLast];

static Display *dpy;

static DC dc = {0};

static Window barwin, root;

static Regs *regs = NULL;

/* configuration, allows nested code to work on above variables */

#include "config.h"

static void

eprint(const char *errstr, ...) {

	va_list ap;

	va_start(ap, errstr);

	vfprintf(stderr, errstr, ap);

	va_end(ap);

	exit(EXIT_FAILURE);

}

static void *

emallocz(unsigned int size) {

	void *res = calloc(1, size);

	if(!res)

		eprint("fatal: could not malloc() %u bytes\n", size);

	return res;

}

static void

spawn(const char *arg) {

	static char *shell = NULL;

	if(!shell && !(shell = getenv("SHELL")))

		shell = "/bin/sh";

	if(!arg)

		return;

	/* The double-fork construct avoids zombie processes and keeps the code

	 * clean from stupid signal handlers. */

	if(fork() == 0) {

		if(fork() == 0) {

			if(dpy)

				close(ConnectionNumber(dpy));

			setsid();

			execl(shell, shell, "-c", arg, (char *)NULL);

			fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg);

			perror(" failed");

		}

		exit(0);

	}

	wait(0);

}

static void

drawsquare(Bool filled, Bool empty, unsigned long col[ColLast]) {

	int x;

	XGCValues gcv;

	XRectangle r = { dc.x, dc.y, dc.w, dc.h };

	gcv.foreground = col[ColFG];

	XChangeGC(dpy, dc.gc, GCForeground, &gcv);

	x = (dc.font.ascent + dc.font.descent + 2) / 4;

	r.x = dc.x + 1;

	r.y = dc.y + 1;

	if(filled) {

		r.width = r.height = x + 1;

		XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);

	}

	else if(empty) {

		r.width = r.height = x;

		XDrawRectangles(dpy, dc.drawable, dc.gc, &r, 1);

	}

}

static unsigned long

initcolor(const char *colstr) {

	Colormap cmap = DefaultColormap(dpy, screen);

	XColor color;

	if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))

		eprint("error, cannot allocate color '%s'\n", colstr);

	return color.pixel;

}

static void

initfont(const char *fontstr) {

	char *def, **missing;

	int i, n;

	missing = NULL;

	if(dc.font.set)

		XFreeFontSet(dpy, dc.font.set);

	dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);

	if(missing) {

		while(n--)

			fprintf(stderr, "dwm: missing fontset: %s\n", missing[n]);

		XFreeStringList(missing);

	}

	if(dc.font.set) {

		XFontSetExtents *font_extents;

		XFontStruct **xfonts;

		char **font_names;

		dc.font.ascent = dc.font.descent = 0;

		font_extents = XExtentsOfFontSet(dc.font.set);

		n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);

		for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {

			if(dc.font.ascent < (*xfonts)->ascent)