nixos-dotfiles

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

#include <stdarg.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 */

#include <X11/Xft/Xft.h>

#include "drw.h"

#include "util.h"

/* macros */

#define BUTTONMASK              (ButtonPressMask|ButtonReleaseMask)

#define CLEANMASK(mask)         (mask & ~(numlockmask|LockMask) & (ShiftMask|ControlMask|Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask))

#define INTERSECT(x,y,w,h,m)    (MAX(0, MIN((x)+(w),(m)->wx+(m)->ww) - MAX((x),(m)->wx)) \

                               * MAX(0, MIN((y)+(h),(m)->wy+(m)->wh) - MAX((y),(m)->wy)))

#define ISVISIBLEONTAG(C, T)    ((C->tags & T))

#define ISVISIBLE(C)            ISVISIBLEONTAG(C, C->mon->tagset[C->mon->seltags])

#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)                (drw_fontset_getwidth(drw, (X)) + lrpad)

/* enums */

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

enum { SchemeNorm, SchemeSel }; /* color schemes */

enum { NetSupported, NetWMName, NetWMState, NetWMCheck,

       NetWMFullscreen, NetActiveWindow, NetWMWindowType,

       NetWMWindowTypeDialog, NetClientList, NetLast }; /* EWMH atoms */

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

enum { ClkTagBar, ClkLtSymbol, ClkStatusText, 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 oldx, oldy, oldw, oldh;

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

	int bw, oldbw;

	unsigned int tags;

	int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen;

	Client *next;

	Client *snext;

	Monitor *mon;

	Window win;

};

typedef struct {

	unsigned int mod;

	KeySym keysym;

} Key;

typedef struct {

    unsigned int n;

    const Key keys[5];

	void (*func)(const Arg *);

	const Arg arg;

} Keychord;

typedef struct {

	const char *symbol;

	void (*arrange)(Monitor *);

} Layout;

struct Monitor {

	char ltsymbol[16];

	float mfact;

	int nmaster;

	int num;

	int by;               /* bar geometry */

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

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

	int gappih;           /* horizontal gap between windows */

	int gappiv;           /* vertical gap between windows */

	int gappoh;           /* horizontal outer gaps */

	int gappov;           /* vertical outer gaps */

	unsigned int seltags;

	unsigned int sellt;

	unsigned int tagset[2];

	int showbar;

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

	int isfloating;

	int monitor;

} Rule;

/* function declarations */

static void applyrules(Client *c);

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

static void arrange(Monitor *m);

static void arrangemon(Monitor *m);

static void attach(Client *c);

static void attachaside(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 clientmessage(XEvent *e);

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 Monitor *dirtomon(int dir);

static void drawbar(Monitor *m);

static void drawbars(void);

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 Atom getatomprop(Client *c, Atom prop);

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

static long getstate(Window w);

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

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

static void grabkeys(void);

static void incnmaster(const Arg *arg);

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 motionnotify(XEvent *e);

static void movemouse(const Arg *arg);

static Client *nexttagged(Client *c);

static Client *nexttiled(Client *c);

static void pop(Client *c);

static void propertynotify(XEvent *e);

static void quit(const Arg *arg);

static Monitor *recttomon(int x, int y, int w, int h);

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

static void resizeclient(Client *c, int x, int y, int w, int h);

static void resizemouse(const Arg *arg);

static void restack(Monitor *m);

static void run(void);

static void scan(void);

static int sendevent(Client *c, Atom proto);

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

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

static void setfocus(Client *c);

static void setfullscreen(Client *c, int fullscreen);

static void fullscreen(const Arg *arg);

static void setlayout(const Arg *arg);

static void setmfact(const Arg *arg);

static void setup(void);

static void seturgent(Client *c, int urg);

static void showhide(Client *c);

static void sighup(int unused);

static void sigterm(int unused);

static void spawn(const Arg *arg);

static void tag(const Arg *arg);

static void tagmon(const Arg *arg);

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, int setfocus);

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

static void unmapnotify(XEvent *e);

static void updatebarpos(Monitor *m);

static void updatebars(void);

static void updateclientlist(void);

static int updategeom(void);

static void updatenumlockmask(void);

static void updatesizehints(Client *c);

static void updatestatus(void);

static void updatetitle(Client *c);

static void updatewindowtype(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;               /* bar height */

static int lrpad;            /* sum of left and right padding for text */

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

static unsigned int numlockmask = 0;

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

	[ButtonPress] = buttonpress,

	[ClientMessage] = clientmessage,

	[ConfigureRequest] = configurerequest,

	[ConfigureNotify] = configurenotify,

	[DestroyNotify] = destroynotify,

	[EnterNotify] = enternotify,

	[Expose] = expose,

	[FocusIn] = focusin,

	[KeyPress] = keypress,

	[MappingNotify] = mappingnotify,

	[MapRequest] = maprequest,

	[MotionNotify] = motionnotify,

	[PropertyNotify] = propertynotify,

	[UnmapNotify] = unmapnotify

};

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

static int restart = 0;

static int running = 1;

static Cur *cursor[CurLast];

static Clr **scheme;

static Display *dpy;

static Drw *drw;

static Monitor *mons, *selmon;

static Window root, wmcheckwin;

unsigned int currentkey = 0;

static Bool leader = False;

/* 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 = { NULL, NULL };

	/* rule matching */

	c->isfloating = 0;

	c->tags = 0;

	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];

}

int

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

{

	int baseismin;

	Monitor *m = c->mon;

	/* set minimum possible */

	*w = MAX(1, *w);

	*h = MAX(1, *h);

	if (interact) {

		if (*x > sw)

			*x = sw - WIDTH(c);

		if (*y > sh)

			*y = sh - HEIGHT(c);

		if (*x + *w + 2 * c->bw < 0)

			*x = 0;

		if (*y + *h + 2 * c->bw < 0)

			*y = 0;

	} else {

		if (*x >= m->wx + m->ww)

			*x = m->wx + m->ww - WIDTH(c);

		if (*y >= m->wy + m->wh)

			*y = m->wy + m->wh - HEIGHT(c);

		if (*x + *w + 2 * c->bw <= m->wx)

			*x = m->wx;

		if (*y + *h + 2 * c->bw <= m->wy)

			*y = m->wy;

	}

	if (*h < bh)

		*h = bh;

	if (*w < bh)

		*w = bh;

	if (resizehints || c->isfloating || !c->mon->lt[c->mon->sellt]->arrange) {

		if (!c->hintsvalid)

			updatesizehints(c);

		/* see last two sentences in ICCCM 4.1.2.3 */

		baseismin = c->basew == c->minw && c->baseh == c->minh;

		if (!baseismin) { /* temporarily remove base dimensions */

			*w -= c->basew;

			*h -= c->baseh;

		}

		/* adjust for aspect limits */

		if (c->mina > 0 && c->maxa > 0) {

			if (c->maxa < (float)*w / *h)

				*w = *h * c->maxa + 0.5;

			else if (c->mina < (float)*h / *w)

				*h = *w * c->mina + 0.5;

		}

		if (baseismin) { /* increment calculation requires this */

			*w -= c->basew;

			*h -= c->baseh;

		}

		/* adjust for increment value */

		if (c->incw)

			*w -= *w % c->incw;

		if (c->inch)

			*h -= *h % c->inch;

		/* restore base dimensions */

		*w = MAX(*w + c->basew, c->minw);

		*h = MAX(*h + c->baseh, c->minh);

		if (c->maxw)

			*w = MIN(*w, c->maxw);

		if (c->maxh)

			*h = MIN(*h, c->maxh);

	}

	return *x != c->x || *y != c->y || *w != c->w || *h != c->h;

}

void

arrange(Monitor *m)

{

	if (m)

		showhide(m->stack);

	else for (m = mons; m; m = m->next)

		showhide(m->stack);

	if (m) {

		arrangemon(m);

		restack(m);

	} else for (m = mons; m; m = m->next)

		arrangemon(m);

}

void

arrangemon(Monitor *m)

{

	strncpy(m->ltsymbol, m->lt[m->sellt]->symbol, sizeof m->ltsymbol);

	if (m->lt[m->sellt]->arrange)

		m->lt[m->sellt]->arrange(m);

}

void

attach(Client *c)

{

	c->next = c->mon->clients;

	c->mon->clients = c;

}

void

attachaside(Client *c) {

	Client *at = nexttagged(c);

	if(!at) {

		attach(c);

		return;

	}

	c->next = at->next;

	at->next = c;

}

void

attachstack(Client *c)

{

	c->snext = c->mon->stack;

	c->mon->stack = c;

}

void

buttonpress(XEvent *e)

{

	unsigned int i, x, click;

	Arg arg = {0};

	Client *c;

	Monitor *m;

	XButtonPressedEvent *ev = &e->xbutton;

	click = ClkRootWin;

	/* focus monitor if necessary */

	if ((m = wintomon(ev->window)) && m != selmon) {

		unfocus(selmon->sel, 1);

		selmon = m;

		focus(NULL);

	}

	if (ev->window == selmon->barwin) {

		i = x = 0;

		unsigned int occ = 0;

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

			occ |= c->tags == TAGMASK ? 0 : c->tags;

		do {

			/* Do not reserve space for vacant tags */

			if (!(occ & 1 << i || m->tagset[m->seltags] & 1 << i))

				continue;

			x += TEXTW(tags[i]);

		} while (ev->x >= x && ++i < LENGTH(tags));

		if (i < LENGTH(tags)) {

			click = ClkTagBar;

			arg.ui = 1 << i;

		} else if (ev->x < x + TEXTW(selmon->ltsymbol))

			click = ClkLtSymbol;

		else

			click = ClkStatusText;

	} else if ((c = wintoclient(ev->window))) {

		focus(c);

		restack(selmon);

		XAllowEvents(dpy, ReplayPointer, CurrentTime);

		click = ClkClientWin;

	}

	for (i = 0; i < LENGTH(buttons); i++)

		if (click == buttons[i].click && buttons[i].func && buttons[i].button == ev->button

		&& CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))

			buttons[i].func(click == ClkTagBar && buttons[i].arg.i == 0 ? &arg : &buttons[i].arg);

}

void

checkotherwm(void)

{

	xerrorxlib = XSetErrorHandler(xerrorstart);

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

	XSelectInput(dpy, DefaultRootWindow(dpy), SubstructureRedirectMask);

	XSync(dpy, False);

	XSetErrorHandler(xerror);

	XSync(dpy, False);

}

void

cleanup(void)

{

	Arg a = {.ui = ~0};

	Layout foo = { "", NULL };

	Monitor *m;

	size_t i;

	view(&a);

	selmon->lt[selmon->sellt] = &foo;

	for (m = mons; m; m = m->next)

		while (m->stack)

			unmanage(m->stack, 0);

	XUngrabKey(dpy, AnyKey, AnyModifier, root);

	while (mons)

		cleanupmon(mons);

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

		drw_cur_free(drw, cursor[i]);

	for (i = 0; i < LENGTH(colors); i++)

		free(scheme[i]);

	free(scheme);

	XDestroyWindow(dpy, wmcheckwin);

	drw_free(drw);

	XSync(dpy, False);

	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);

	XDeleteProperty(dpy, root, netatom[NetActiveWindow]);

}

void

cleanupmon(Monitor *mon)

{

	Monitor *m;

	if (mon == mons)

		mons = mons->next;

	else {

		for (m = mons; m && m->next != mon; m = m->next);

		m->next = mon->next;

	}

	XUnmapWindow(dpy, mon->barwin);

	XDestroyWindow(dpy, mon->barwin);

	free(mon);

}

void

clientmessage(XEvent *e)

{

	XClientMessageEvent *cme = &e->xclient;

	Client *c = wintoclient(cme->window);

	if (!c)

		return;

	if (cme->message_type == netatom[NetWMState]) {

		if (cme->data.l[1] == netatom[NetWMFullscreen]

		|| cme->data.l[2] == netatom[NetWMFullscreen])

			setfullscreen(c, (cme->data.l[0] == 1 /* _NET_WM_STATE_ADD    */

				|| (cme->data.l[0] == 2 /* _NET_WM_STATE_TOGGLE */ && !c->isfullscreen)));

	} else if (cme->message_type == netatom[NetActiveWindow]) {

		if (c != selmon->sel && !c->isurgent)

			seturgent(c, 1);

	}

}

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->bw;

	ce.above = None;

	ce.override_redirect = False;

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

}

void

configurenotify(XEvent *e)

{

	Monitor *m;

	Client *c;

	XConfigureEvent *ev = &e->xconfigure;

	int dirty;

	/* TODO: updategeom handling sucks, needs to be simplified */

	if (ev->window == root) {

		dirty = (sw != ev->width || sh != ev->height);

		sw = ev->width;

		sh = ev->height;

		if (updategeom() || dirty) {

			drw_resize(drw, sw, bh);

			updatebars();

			for (m = mons; m; m = m->next) {

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

					if (c->isfullscreen)

						resizeclient(c, m->mx, m->my, m->mw, m->mh);

				XMoveResizeWindow(dpy, m->barwin, m->wx, m->by, m->ww, bh);

			}

			focus(NULL);

			arrange(NULL);

		}

	}

}

void

configurerequest(XEvent *e)

{

	Client *c;

	Monitor *m;

	XConfigureRequestEvent *ev = &e->xconfigurerequest;

	XWindowChanges wc;

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

		if (ev->value_mask & CWBorderWidth)

			c->bw = ev->border_width;

		else if (c->isfloating || !selmon->lt[selmon->sellt]->arrange) {

			m = c->mon;

			if (ev->value_mask & CWX) {

				c->oldx = c->x;

				c->x = m->mx + ev->x;

			}

			if (ev->value_mask & CWY) {

				c->oldy = c->y;

				c->y = m->my + ev->y;

			}

			if (ev->value_mask & CWWidth) {

				c->oldw = c->w;

				c->w = ev->width;

			}

			if (ev->value_mask & CWHeight) {

				c->oldh = c->h;

				c->h = ev->height;

			}

			if ((c->x + c->w) > m->mx + m->mw && c->isfloating)

				c->x = m->mx + (m->mw / 2 - WIDTH(c) / 2); /* center in x direction */

			if ((c->y + c->h) > m->my + m->mh && c->isfloating)

				c->y = m->my + (m->mh / 2 - HEIGHT(c) / 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);

}

Monitor *

createmon(void)

{

	Monitor *m;

	m = ecalloc(1, sizeof(Monitor));

	m->tagset[0] = m->tagset[1] = 1;

	m->mfact = mfact;

	m->nmaster = nmaster;

	m->showbar = showbar;

	m->topbar = topbar;

	m->gappih = gappih;

	m->gappiv = gappiv;

	m->gappoh = gappoh;

	m->gappov = gappov;

	m->lt[0] = &layouts[0];

	m->lt[1] = &layouts[1 % LENGTH(layouts)];

	strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol);

	return m;

}

void

destroynotify(XEvent *e)

{

	Client *c;

	XDestroyWindowEvent *ev = &e->xdestroywindow;

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

		unmanage(c, 1);

}

void

detach(Client *c)

{

	Client **tc;

	for (tc = &c->mon->clients; *tc && *tc != c; tc = &(*tc)->next);

	*tc = c->next;

}

void

detachstack(Client *c)

{

	Client **tc, *t;

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

	*tc = c->snext;

	if (c == c->mon->sel) {

		for (t = c->mon->stack; t && !ISVISIBLE(t); t = t->snext);

		c->mon->sel = t;

	}

}

Monitor *

dirtomon(int dir)

{

	Monitor *m = NULL;

	if (dir > 0) {

		if (!(m = selmon->next))

			m = mons;

	} else if (selmon == mons)

		for (m = mons; m->next; m = m->next);

	else

		for (m = mons; m->next != selmon; m = m->next);

	return m;

}

void

drawbar(Monitor *m)

{

	int x, w, tw = 0;

	unsigned int i, occ = 0, urg = 0;

	Client *c;

	if (!m->showbar)

		return;

	/* draw status first so it can be overdrawn by tags later */

	if (m == selmon) { /* status is only drawn on selected monitor */

		drw_setscheme(drw, scheme[SchemeNorm]);

		tw = TEXTW(stext) - lrpad + 2; /* 2px right padding */

		drw_text(drw, m->ww - tw, 0, tw, bh, 0, stext, 0);

	}

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

		occ |= c->tags == TAGMASK ? 0 : c->tags;

		if (c->isurgent)

			urg |= c->tags;

	}

	x = 0;

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

		/* Do not draw vacant tags */

		if(!(occ & 1 << i || m->tagset[m->seltags] & 1 << i))

			continue;

		w = TEXTW(tags[i]);

		drw_setscheme(drw, scheme[m->tagset[m->seltags] & 1 << i ? SchemeSel : SchemeNorm]);

		drw_text(drw, x, 0, w, bh, lrpad / 2, tags[i], urg & 1 << i);

		x += w;

	}

	w = TEXTW(m->ltsymbol);

	drw_setscheme(drw, scheme[SchemeNorm]);

	x = drw_text(drw, x, 0, w, bh, lrpad / 2, m->ltsymbol, 0);

    if ((w = m->ww - tw - x) > bh) {

        drw_setscheme(drw, scheme[SchemeNorm]);

        drw_rect(drw, x, 0, w, bh, 1, 1);

    }

    drw_map(drw, m->barwin, 0, 0, m->ww, bh);

}

void

drawbars(void)

{

	Monitor *m;

	for (m = mons; m; m = m->next)

		drawbar(m);

}

void

enternotify(XEvent *e)

{

	Client *c;

	Monitor *m;

	XCrossingEvent *ev = &e->xcrossing;

	if ((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)

		return;

	c = wintoclient(ev->window);

	m = c ? c->mon : wintomon(ev->window);

	if (m != selmon) {

		unfocus(selmon->sel, 1);

		selmon = m;

	} else if (!c || c == selmon->sel)

		return;

	focus(c);

}

void

expose(XEvent *e)

{

	Monitor *m;

	XExposeEvent *ev = &e->xexpose;

	if (ev->count == 0 && (m = wintomon(ev->window)))

		drawbar(m);

}

void

focus(Client *c)

{

	if (!c || !ISVISIBLE(c))

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

	if (selmon->sel && selmon->sel != c)

		unfocus(selmon->sel, 0);

	if (c) {

		if (c->mon != selmon)

			selmon = c->mon;

		if (c->isurgent)

			seturgent(c, 0);

		detachstack(c);

		attachstack(c);

		grabbuttons(c, 1);

		XSetWindowBorder(dpy, c->win, scheme[SchemeSel][ColBorder].pixel);

		setfocus(c);

	} else {

		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);

		XDeleteProperty(dpy, root, netatom[NetActiveWindow]);

	}

	selmon->sel = c;

	drawbars();

}

/* there are some broken focus acquiring clients needing extra handling */

void

focusin(XEvent *e)

{

	XFocusChangeEvent *ev = &e->xfocus;

	if (selmon->sel && ev->window != selmon->sel->win)

		setfocus(selmon->sel);

}

void

focusmon(const Arg *arg)

{

	Monitor *m;

	if (!mons->next)

		return;

	if ((m = dirtomon(arg->i)) == selmon)

		return;

	unfocus(selmon->sel, 0);

	selmon = m;

	focus(NULL);

}

void

focusstack(const Arg *arg)

{

	Client *c = NULL, *i;

	if (!selmon->sel || (selmon->sel->isfullscreen && lockfullscreen))

		return;

	if (arg->i > 0) {

		for (c = selmon->sel->next; c && !ISVISIBLE(c); c = c->next);

		if (!c)

			for (c = selmon->clients; c && !ISVISIBLE(c); c = c->next);

	} else {

		for (i = selmon->clients; i != selmon->sel; i = i->next)

			if (ISVISIBLE(i))

				c = i;

		if (!c)

			for (; i; i = i->next)

				if (ISVISIBLE(i))

					c = i;

	}

	if (c) {

		focus(c);

		restack(selmon);

	}

}

Atom

getatomprop(Client *c, Atom prop)

{

	int di;

	unsigned long dl;

	unsigned char *p = NULL;

	Atom da, atom = None;

	if (XGetWindowProperty(dpy, c->win, prop, 0L, sizeof atom, False, XA_ATOM,

		&da, &di, &dl, &dl, &p) == Success && p) {

		atom = *(Atom *)p;

		XFree(p);

	}

	return atom;

}

int

getrootptr(int *x, int *y)

{

	int di;

	unsigned int dui;

	Window dummy;

	return XQueryPointer(dpy, root, &dummy, &dummy, x, y, &di, &di, &dui);

}

long

getstate(Window w)

{

	int format;

	long result = -1;

	unsigned char *p = NULL;

	unsigned long n, extra;

	Atom real;

	if (XGetWindowProperty(dpy, w, wmatom[WMState], 0L, 2L, False, wmatom[WMState],

		&real, &format, &n, &extra, (unsigned char **)&p) != Success)

		return -1;

	if (n != 0)

		result = *p;

	XFree(p);

	return result;

}

int

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

{

	char **list = NULL;

	int n;

	XTextProperty name;

	if (!text || size == 0)

		return 0;

	text[0] = '\0';

	if (!XGetTextProperty(dpy, w, &name, atom) || !name.nitems)

		return 0;

	if (name.encoding == XA_STRING) {

		strncpy(text, (char *)name.value, size - 1);

	} else if (XmbTextPropertyToTextList(dpy, &name, &list, &n) >= Success && n > 0 && *list) {

		strncpy(text, *list, size - 1);

		XFreeStringList(list);

	}

	text[size - 1] = '\0';

	XFree(name.value);

	return 1;

}

void

grabbuttons(Client *c, int focused)

{

	updatenumlockmask();

	{

		unsigned int i, j;

		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };

		XUngrabButton(dpy, AnyButton, AnyModifier, c->win);

		if (!focused)

			XGrabButton(dpy, AnyButton, AnyModifier, c->win, False,

				BUTTONMASK, GrabModeSync, GrabModeSync, None, None);

		for (i = 0; i < LENGTH(buttons); i++)

			if (buttons[i].click == ClkClientWin)

				for (j = 0; j < LENGTH(modifiers); j++)

					XGrabButton(dpy, buttons[i].button,

						buttons[i].mask | modifiers[j],

						c->win, False, BUTTONMASK,

						GrabModeAsync, GrabModeSync, None, None);

	}

}

void

grabkeys(void)

{

	updatenumlockmask();

	{

		/* unsigned int i, j, k; */

		unsigned int i, c, k;

		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };

		int start, end, skip;

		KeySym *syms;

		XUngrabKey(dpy, AnyKey, AnyModifier, root);

		XDisplayKeycodes(dpy, &start, &end);

		syms = XGetKeyboardMapping(dpy, start, end - start + 1, &skip);

		if (!syms)

			return;

		for (k = start; k <= end; k++)

			for (i = 0; i < LENGTH(keychords); i++)

				/* skip modifier codes, we do that ourselves */

				if (keychords[i]->keys[currentkey].keysym == syms[(k - start) * skip])

					for (c = 0; c < LENGTH(modifiers); c++)

						XGrabKey(dpy, k,

							 keychords[i]->keys[currentkey].mod | modifiers[c],

							 root, True,

							 GrabModeAsync, GrabModeAsync);

                if(currentkey > 0)

                        XGrabKey(dpy, XKeysymToKeycode(dpy, XK_Escape), AnyModifier, root, True, GrabModeAsync, GrabModeAsync);

		XFree(syms);

	}

}

void

incnmaster(const Arg *arg)

{

	selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);

	arrange(selmon);

}

#ifdef XINERAMA

static int

isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info)

{

	while (n--)

		if (unique[n].x_org == info->x_org && unique[n].y_org == info->y_org

		&& unique[n].width == info->width && unique[n].height == info->height)

			return 0;

	return 1;

}

#endif /* XINERAMA */

void

keypress(XEvent *e)

{

	/* unsigned int i; */

    XEvent event = *e;

    unsigned int ran = 0;

	KeySym keysym;

	XKeyEvent *ev;

    Keychord *arr1[sizeof(keychords) / sizeof(Keychord*)];

    Keychord *arr2[sizeof(keychords) / sizeof(Keychord*)];

    memcpy(arr1, keychords, sizeof(keychords));

    Keychord **rpointer = arr1;

    Keychord **wpointer = arr2;

    size_t r = sizeof(keychords)/ sizeof(Keychord*);

    while(1){

            ev = &event.xkey;

            keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);

            size_t w = 0;

            for (int i = 0; i < r; i++){

                    if(keysym == (*(rpointer + i))->keys[currentkey].keysym

                       && CLEANMASK((*(rpointer + i))->keys[currentkey].mod) == CLEANMASK(ev->state)

                       && (*(rpointer + i))->func){

                            if((*(rpointer + i))->n == currentkey +1){

                                    (*(rpointer + i))->func(&((*(rpointer + i))->arg));

                                    ran = 1;

                            }else{

                                    *(wpointer + w) = *(rpointer + i);

                                    w++;

                            }

                    }

            }

            currentkey++;

            if(w == 0 || ran == 1)

                    break;

            grabkeys();

            while (running && !XNextEvent(dpy, &event) && !ran)

                    if(event.type == KeyPress)

                            break;

            r = w;

            Keychord **holder = rpointer;

            rpointer = wpointer;

            wpointer = holder;

    }

    currentkey = 0;

    grabkeys();

}

/*void*/

/*keypress(XEvent *e)*/

/*{*/

/*    unsigned int i;*/

/*    KeySym keysym;*/

/*    XKeyEvent *ev;*/

/**/

/*    ev = &e->xkey;*/

/*    keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);*/

/**/

/*    printf("keysym: %lu (%d), ev->state: %u\n", keysym, keysym, ev->state);*/

/*    printf("keysym: %lu, ev->state: %u\n", keysym, ev->state);*/

/**/

/*    fflush(stdout);*/

/**/

/*    if (leader) {*/

/*        for (i = 0; i < LENGTH(leaderkeys); i++) {*/

/*            if (keysym == leaderkeys[i].keysym) {*/

/*                leaderkeys[i].func(&(leaderkeys[i].arg));*/

/*                leader = False;*/

/*                return;*/

/*            }*/

/*        }*/

/**/

/*        // Esc cancels leader mode*/

/*        if (keysym == XK_Escape) {*/

/*            leader = False;*/

/*            return;*/

/*        }*/

/**/

/*        // fallback exit*/

/*        leader = False;*/

/*        return;*/

/*    }*/

/**/

/*    if (keysym == XK_space && CLEANMASK(ev->state) == MODKEY) {*/

/*        leader = True;*/

/*        return;*/

/*    }*/

/**/

/*    for (i = 0; i < LENGTH(keys); i++) {*/

/*        if (keysym == keys[i].keysym*/

/*            && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)) {*/

/*            keys[i].func(&(keys[i].arg));*/

/*            return;*/

/*        }*/

/*    }*/

/*}*/

void

killclient(const Arg *arg)

{

	if (!selmon->sel)

		return;

	if (!sendevent(selmon->sel, wmatom[WMDelete])) {

		XGrabServer(dpy);

		XSetErrorHandler(xerrordummy);

		XSetCloseDownMode(dpy, DestroyAll);

		XKillClient(dpy, selmon->sel->win);

		XSync(dpy, False);

		XSetErrorHandler(xerror);

		XUngrabServer(dpy);

	}

}

void

manage(Window w, XWindowAttributes *wa)

{

	Client *c, *t = NULL;

	Window trans = None;

	XWindowChanges wc;

	c = ecalloc(1, sizeof(Client));

	c->win = w;

	/* geometry */

	c->x = c->oldx = wa->x;

	c->y = c->oldy = wa->y;

	c->w = c->oldw = wa->width;

	c->h = c->oldh = wa->height;

	c->oldbw = wa->border_width;

	updatetitle(c);

	if (XGetTransientForHint(dpy, w, &trans) && (t = wintoclient(trans))) {

		c->mon = t->mon;

		c->tags = t->tags;

	} else {

		c->mon = selmon;

		applyrules(c);

	}

	if (c->x + WIDTH(c) > c->mon->wx + c->mon->ww)

		c->x = c->mon->wx + c->mon->ww - WIDTH(c);

	if (c->y + HEIGHT(c) > c->mon->wy + c->mon->wh)

		c->y = c->mon->wy + c->mon->wh - HEIGHT(c);

	c->x = MAX(c->x, c->mon->wx);

	c->y = MAX(c->y, c->mon->wy);

	c->bw = borderpx;

	wc.border_width = c->bw;

	XConfigureWindow(dpy, w, CWBorderWidth, &wc);

	XSetWindowBorder(dpy, w, scheme[SchemeNorm][ColBorder].pixel);

	configure(c); /* propagates border_width, if size doesn't change */

	updatewindowtype(c);

	updatesizehints(c);

	updatewmhints(c);

	XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);

	grabbuttons(c, 0);

	if (!c->isfloating)

		c->isfloating = c->oldstate = trans != None || c->isfixed;

	if (c->isfloating)

		XRaiseWindow(dpy, c->win);

	attachaside(c);

	attachstack(c);

	XChangeProperty(dpy, root, netatom[NetClientList], XA_WINDOW, 32, PropModeAppend,

		(unsigned char *) &(c->win), 1);

	XMoveResizeWindow(dpy, c->win, c->x + 2 * sw, c->y, c->w, c->h); /* some windows require this */

	setclientstate(c, NormalState);

	if (c->mon == selmon)

		unfocus(selmon->sel, 0);

	c->mon->sel = c;

	arrange(c->mon);

	XMapWindow(dpy, c->win);

	focus(NULL);

}

void

mappingnotify(XEvent *e)

{

	XMappingEvent *ev = &e->xmapping;

	XRefreshKeyboardMapping(ev);

	if (ev->request == MappingKeyboard)

		grabkeys();

}

void

maprequest(XEvent *e)

{

	static XWindowAttributes wa;

	XMapRequestEvent *ev = &e->xmaprequest;

	if (!XGetWindowAttributes(dpy, ev->window, &wa) || wa.override_redirect)

		return;

	if (!wintoclient(ev->window))

		manage(ev->window, &wa);

}

void

monocle(Monitor *m)

{

	unsigned int n = 0;

	Client *c;

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

		if (ISVISIBLE(c))

			n++;

	if (n > 0) /* override layout symbol */

		snprintf(m->ltsymbol, sizeof m->ltsymbol, "[%d]", n);

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

		resize(c, m->wx, m->wy, m->ww - 2 * c->bw, m->wh - 2 * c->bw, 0);

}

void

motionnotify(XEvent *e)

{

	static Monitor *mon = NULL;

	Monitor *m;

	XMotionEvent *ev = &e->xmotion;

	if (ev->window != root)

		return;

	if ((m = recttomon(ev->x_root, ev->y_root, 1, 1)) != mon && mon) {

		unfocus(selmon->sel, 1);

		selmon = m;

		focus(NULL);

	}

	mon = m;

}

void

movemouse(const Arg *arg)

{

	int x, y, ocx, ocy, nx, ny;

	Client *c;

	Monitor *m;

	XEvent ev;

	Time lasttime = 0;

	if (!(c = selmon->sel))

		return;

	if (c->isfullscreen) /* no support moving fullscreen windows by mouse */

		return;

	restack(selmon);

	ocx = c->x;

	ocy = c->y;

	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,

		None, cursor[CurMove]->cursor, CurrentTime) != GrabSuccess)

		return;

	if (!getrootptr(&x, &y))

		return;

	do {

		XMaskEvent(dpy, MOUSEMASK|ExposureMask|SubstructureRedirectMask, &ev);

		switch(ev.type) {

		case ConfigureRequest:

		case Expose:

		case MapRequest:

			handler[ev.type](&ev);

			break;

		case MotionNotify:

			if ((ev.xmotion.time - lasttime) <= (1000 / 60))

				continue;

			lasttime = ev.xmotion.time;

			nx = ocx + (ev.xmotion.x - x);

			ny = ocy + (ev.xmotion.y - y);

			if (abs(selmon->wx - nx) < snap)

				nx = selmon->wx;

			else if (abs((selmon->wx + selmon->ww) - (nx + WIDTH(c))) < snap)

				nx = selmon->wx + selmon->ww - WIDTH(c);

			if (abs(selmon->wy - ny) < snap)

				ny = selmon->wy;

			else if (abs((selmon->wy + selmon->wh) - (ny + HEIGHT(c))) < snap)

				ny = selmon->wy + selmon->wh - HEIGHT(c);

			if (!c->isfloating && selmon->lt[selmon->sellt]->arrange

			&& (abs(nx - c->x) > snap || abs(ny - c->y) > snap))

				togglefloating(NULL);

			if (!selmon->lt[selmon->sellt]->arrange || c->isfloating)

				resize(c, nx, ny, c->w, c->h, 1);

			break;

		}

	} while (ev.type != ButtonRelease);

	XUngrabPointer(dpy, CurrentTime);

	if ((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) {

		sendmon(c, m);

		selmon = m;

		focus(NULL);

	}

}

Client *

nexttagged(Client *c) {

	Client *walked = c->mon->clients;

	for(;

		walked && (walked->isfloating || !ISVISIBLEONTAG(walked, c->tags));

		walked = walked->next

	);

	return walked;

}

Client *