/* 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.

 *

 * 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 linked client

 * list on each monitor, the focus history is remembered through a stack list

 * on each monitor. Each client contains a bit array to indicate the tags of a

 * client.

 *

 * 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 <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <X11/cursorfont.h>

#include <X11/keysym.h>

#include <X11/Xatom.h>

#include <X11/Xlib.h>

#include <X11/Xproto.h>

#include <X11/Xutil.h>

#ifdef XINERAMA

#include <X11/extensions/Xinerama.h>

#endif /* XINERAMA */

/* macros */

#define BUTTONMASK              (ButtonPressMask|ButtonReleaseMask)

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

#define INRECT(X,Y,RX,RY,RW,RH) ((X) >= (RX) && (X) < (RX) + (RW) && (Y) >= (RY) && (Y) < (RY) + (RH))

#define ISVISIBLE(C)            ((C->tags & C->mon->tagset[C->mon->seltags]))

#define LENGTH(X)               (sizeof X / sizeof X[0])

#define MAX(A, B)               ((A) > (B) ? (A) : (B))

#define MIN(A, B)               ((A) < (B) ? (A) : (B))

#define MOUSEMASK               (BUTTONMASK|PointerMotionMask)

#define WIDTH(X)                ((X)->w + 2 * (X)->bw)

#define HEIGHT(X)               ((X)->h + 2 * (X)->bw)

#define TAGMASK                 ((1 << LENGTH(tags)) - 1)

#define TEXTW(X)                (textnw(X, strlen(X)) + dc.font.height)

/* enums */

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

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

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

enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle,

       ClkClientWin, ClkRootWin, ClkLast };             /* clicks */

typedef union {

	int i;

	unsigned int ui;

	float f;

	const void *v;

} Arg;

typedef struct {

	unsigned int click;

	unsigned int mask;

	unsigned int button;

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

	const Arg arg;

} Button;

typedef struct Monitor Monitor;

typedef struct Client Client;

struct Client {

	char name[256];

	float mina, maxa;

	int x, y, w, h;

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

	int bw, oldbw;

	unsigned int tags;

	Bool isfixed, isfloating, isurgent;

	Client *next;

	Client *snext;

	Monitor *mon;

	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 int mod;

	KeySym keysym;

	void (*func)(const Arg *);

	const Arg arg;

} Key;

typedef struct {

	const char *symbol;

	void (*arrange)(Monitor *);

} Layout;

struct Monitor {

	char ltsymbol[16];

	float mfact;

	int num;

	int by;               /* bar geometry */

	int mx, my, mw, mh;   /* screen size */

	int wx, wy, ww, wh;   /* window area  */

	unsigned int seltags;

	unsigned int sellt;

	unsigned int tagset[2];

	Bool showbar;

	Bool topbar;

	Client *clients;

	Client *sel;

	Client *stack;

	Monitor *next;

	Window barwin;

	const Layout *lt[2];

};

typedef struct {

	const char *class;

	const char *instance;

	const char *title;

	unsigned int tags;

	Bool isfloating;

	int monitor;

} Rule;

/* function declarations */

static void applyrules(Client *c);

static Bool applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact);

static void arrange(Monitor *m);

static void arrangemon(Monitor *m);

static void attach(Client *c);

static void attachstack(Client *c);

static void buttonpress(XEvent *e);

static void checkotherwm(void);

static void cleanup(void);

static void cleanupmon(Monitor *mon);

static void clearurgent(Client *c);

static void configure(Client *c);

static void configurenotify(XEvent *e);

static void configurerequest(XEvent *e);

static Monitor *createmon(void);

static void destroynotify(XEvent *e);

static void detach(Client *c);

static void detachstack(Client *c);

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

static Monitor *dirtomon(int dir);

static void drawbar(Monitor *m);

static void drawbars(void);

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

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

static void enternotify(XEvent *e);

static void expose(XEvent *e);

static void focus(Client *c);

static void focusin(XEvent *e);

static void focusmon(const Arg *arg);

static void focusstack(const Arg *arg);

static unsigned long getcolor(const char *colstr);

static Bool getrootptr(int *x, int *y);

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 void grabkeys(void);

static void initfont(const char *fontstr);

static Bool isprotodel(Client *c);

static void keypress(XEvent *e);

static void killclient(const Arg *arg);

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

static void mappingnotify(XEvent *e);

static void maprequest(XEvent *e);

static void monocle(Monitor *m);

static void movemouse(const Arg *arg);

static Client *nexttiled(Client *c);

static Monitor *ptrtomon(int x, int y);

static void propertynotify(XEvent *e);

static void quit(const Arg *arg);

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

static void resizemouse(const Arg *arg);

static void restack(Monitor *m);

static void run(void);

static void scan(void);

static void sendmon(Client *c, Monitor *m);

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

static void setlayout(const Arg *arg);

static void setmfact(const Arg *arg);

static void setup(void);

static void showhide(Client *c);

static void sigchld(int unused);

static void spawn(const Arg *arg);

static void tag(const Arg *arg);

static void tagmon(const Arg *arg);

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

static void tile(Monitor *);

static void togglebar(const Arg *arg);

static void togglefloating(const Arg *arg);

static void toggletag(const Arg *arg);

static void toggleview(const Arg *arg);

static void unfocus(Client *c);

static void unmanage(Client *c, Bool destroyed);

static void unmapnotify(XEvent *e);

static Bool updategeom(void);

static void updatebarpos(Monitor *m);

static void updatebars(void);

static void updatenumlockmask(void);

static void updatesizehints(Client *c);

static void updatestatus(void);

static void updatetitle(Client *c);

static void updatewmhints(Client *c);

static void view(const Arg *arg);

static Client *wintoclient(Window w);

static Monitor *wintomon(Window w);

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

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

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

static void zoom(const Arg *arg);

/* variables */

static const char broken[] = "broken";

static char stext[256];

static int screen;

static int sw, sh;           /* X display screen geometry width, height */

static int bh, blw = 0;      /* bar geometry */

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

static unsigned int numlockmask = 0;

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

	[ButtonPress] = buttonpress,

	[ConfigureRequest] = configurerequest,

	[ConfigureNotify] = configurenotify,

	[DestroyNotify] = destroynotify,

	[EnterNotify] = enternotify,

	[Expose] = expose,

	[FocusIn] = focusin,

	[KeyPress] = keypress,

	[MappingNotify] = mappingnotify,

	[MapRequest] = maprequest,

	[PropertyNotify] = propertynotify,

	[UnmapNotify] = unmapnotify

};

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

static Bool otherwm;

static Bool running = True;

static Cursor cursor[CurLast];

static Display *dpy;

static DC dc;

static Monitor *mons = NULL, *selmon = NULL;

static Window root;

/* configuration, allows nested code to access above variables */

#include "config.h"

/* compile-time check if all tags fit into an unsigned int bit array. */

struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1 : 1]; };

/* function implementations */

void

applyrules(Client *c) {

	const char *class, *instance;

	unsigned int i;

	const Rule *r;

	Monitor *m;

	XClassHint ch = { 0 };

	/* rule matching */

	c->isfloating = c->tags = 0;

	if(XGetClassHint(dpy, c->win, &ch)) {

		class = ch.res_class ? ch.res_class : broken;

		instance = ch.res_name ? ch.res_name : broken;

		for(i = 0; i < LENGTH(rules); i++) {

			r = &rules[i];

			if((!r->title || strstr(c->name, r->title))

			&& (!r->class || strstr(class, r->class))

			&& (!r->instance || strstr(instance, r->instance)))

			{

				c->isfloating = r->isfloating;

				c->tags |= r->tags;

				for(m = mons; m && m->num != r->monitor; m = m->next);

				if(m)

					c->mon = m;

			}

		}

		if(ch.res_class)

			XFree(ch.res_class);

		if(ch.res_name)

			XFree(ch.res_name);

	}

	c->tags = c->tags & TAGMASK ? c->tags & TAGMASK : c->mon->tagset[c->mon->seltags];

}

Bool

applysizehints(Client *c, int *x, int *y, int *w, int *h, Bool interact) {

	Bool baseismin;

	Monitor *m = c->mon;

	/* set minimum possible */

	*w = MAX(1, *w);