Add patches and patched files - dotfiles - Unnamed repository; edit this file 'description' to name the repository.

commit 977e9aa59159f4d8c8d1a4fcc96da2c6ced2c773
parent 06a62b95aec6d128cabdef45c88860373b808062
Author: Janis Pagel <janis.pagel@ims.uni-stuttgart.de>
Date:   Sun, 15 Dec 2019 12:34:49 +0100

Add patches and patched files

Diffstat:
A suckless/dmenu/config.def.h  | 26 ++++++++++++++++++++++++++
A suckless/dmenu/dmenu-border-4.9.diff  | 25 +++++++++++++++++++++++++
A suckless/dmenu/dmenu-center-4.8.diff  | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A suckless/dwm/dwm-pertag-20170513-ceac8c9.diff  | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A suckless/dwm/dwm.c  | 2225 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A suckless/surf/config.def.h  | 169 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A suckless/surf/surf-git-20170323-webkit2-searchengines.diff  | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A suckless/surf/surf-modal-20190209-d068a38.diff  | 134 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A suckless/surf/surf.c  | 1789 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

9 files changed, 4657 insertions(+), 0 deletions(-)
diff --git a/suckless/dmenu/config.def.h b/suckless/dmenu/config.def.h
@@ -0,0 +1,26 @@
+/* See LICENSE file for copyright and license details. */
+/* Default settings; can be overriden by command line. */
+
+static int topbar = 1;                      /* -b  option; if 0, dmenu appears at bottom     */
+/* -fn option overrides fonts[0]; default X11 font or font set */
+static const char *fonts[] = {
+	"monospace:size=10"
+};
+static const char *prompt      = NULL;      /* -p  option; prompt to the left of input field */
+static const char *colors[SchemeLast][2] = {
+	/*     fg         bg       */
+	[SchemeNorm] = { "#bbbbbb", "#222222" },
+	[SchemeSel] = { "#eeeeee", "#005577" },
+	[SchemeOut] = { "#000000", "#00ffff" },
+};
+/* -l option; if nonzero, dmenu uses vertical list with given number of lines */
+static unsigned int lines      = 0;
+
+/*
+ * Characters not considered part of a word while deleting words
+ * for example: " /?\"&[]"
+ */
+static const char worddelimiters[] = " ";
+
+/* Size of the window border */
+static const unsigned int border_width = 5;
diff --git a/suckless/dmenu/dmenu-border-4.9.diff b/suckless/dmenu/dmenu-border-4.9.diff
@@ -0,0 +1,25 @@
+diff -up dmenu-4.9-b/config.def.h dmenu-4.9-a/config.def.h
+--- dmenu-4.9-b/config.def.h	2019-02-02 13:55:02.000000000 +0100
++++ dmenu-4.9-a/config.def.h	2019-05-19 02:10:12.740040403 +0200
+@@ -21,3 +21,6 @@ static unsigned int lines      = 0;
+  * for example: " /?\"&[]"
+  */
+ static const char worddelimiters[] = " ";
++
++/* Size of the window border */
++static const unsigned int border_width = 5;
+diff -up dmenu-4.9-b/dmenu.c dmenu-4.9-a/dmenu.c
+--- dmenu-4.9-b/dmenu.c	2019-02-02 13:55:02.000000000 +0100
++++ dmenu-4.9-a/dmenu.c	2019-05-19 02:11:20.966710117 +0200
+@@ -654,9 +654,10 @@ setup(void)
+ 	swa.override_redirect = True;
+ 	swa.background_pixel = scheme[SchemeNorm][ColBg].pixel;
+ 	swa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;
+-	win = XCreateWindow(dpy, parentwin, x, y, mw, mh, 0,
++	win = XCreateWindow(dpy, parentwin, x, y, mw, mh, border_width,
+ 	                    CopyFromParent, CopyFromParent, CopyFromParent,
+ 	                    CWOverrideRedirect | CWBackPixel | CWEventMask, &swa);
++	XSetWindowBorder(dpy, win, scheme[SchemeSel][ColBg].pixel);
+ 	XSetClassHint(dpy, win, &ch);
+ 
+ 	/* open input methods */
diff --git a/suckless/dmenu/dmenu-center-4.8.diff b/suckless/dmenu/dmenu-center-4.8.diff
@@ -0,0 +1,56 @@
+diff --git a/dmenu.c b/dmenu.c
+index 5e9c367..2268ea9 100644
+--- a/dmenu.c
++++ b/dmenu.c
+@@ -88,6 +88,15 @@ calcoffsets(void)
+ 			break;
+ }
+ 
++static int
++max_textw(void)
++{
++	int len = 0;
++	for (struct item *item = items; item && item->text; item++)
++		len = MAX(TEXTW(item->text), len);
++	return len;
++}
++
+ static void
+ cleanup(void)
+ {
+@@ -598,6 +607,7 @@ setup(void)
+ 	bh = drw->fonts->h + 2;
+ 	lines = MAX(lines, 0);
+ 	mh = (lines + 1) * bh;
++	promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0;
+ #ifdef XINERAMA
+ 	i = 0;
+ 	if (parentwin == root && (info = XineramaQueryScreens(dpy, &n))) {
+@@ -624,9 +634,9 @@ setup(void)
+ 				if (INTERSECT(x, y, 1, 1, info[i]))
+ 					break;
+ 
+-		x = info[i].x_org;
+-		y = info[i].y_org + (topbar ? 0 : info[i].height - mh);
+-		mw = info[i].width;
++		mw = MIN(MAX(max_textw() + promptw, 100), info[i].width);
++		x = info[i].x_org + ((info[i].width  - mw) / 2);
++		y = info[i].y_org + ((info[i].height - mh) / 2);
+ 		XFree(info);
+ 	} else
+ #endif
+@@ -634,11 +644,10 @@ setup(void)
+ 		if (!XGetWindowAttributes(dpy, parentwin, &wa))
+ 			die("could not get embedding window attributes: 0x%lx",
+ 			    parentwin);
+-		x = 0;
+-		y = topbar ? 0 : wa.height - mh;
+-		mw = wa.width;
++		mw = MIN(MAX(max_textw() + promptw, 100), wa.width);
++		x = (wa.width  - mw) / 2;
++		y = (wa.height - mh) / 2;
+ 	}
+-	promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0;
+ 	inputw = MIN(inputw, mw/3);
+ 	match();
+ 
diff --git a/suckless/dwm/dwm-pertag-20170513-ceac8c9.diff b/suckless/dwm/dwm-pertag-20170513-ceac8c9.diff
@@ -0,0 +1,177 @@
+diff --git a/dwm.c b/dwm.c
+index a5ce993..45f1e27 100644
+--- a/dwm.c
++++ b/dwm.c
+@@ -112,6 +112,7 @@ typedef struct {
+ 	void (*arrange)(Monitor *);
+ } Layout;
+ 
++typedef struct Pertag Pertag;
+ struct Monitor {
+ 	char ltsymbol[16];
+ 	float mfact;
+@@ -131,6 +132,7 @@ struct Monitor {
+ 	Monitor *next;
+ 	Window barwin;
+ 	const Layout *lt[2];
++	Pertag *pertag;
+ };
+ 
+ typedef struct {
+@@ -272,6 +274,15 @@ static Window root, wmcheckwin;
+ /* configuration, allows nested code to access above variables */
+ #include "config.h"
+ 
++struct Pertag {
++	unsigned int curtag, prevtag; /* current and previous tag */
++	int nmasters[LENGTH(tags) + 1]; /* number of windows in master area */
++	float mfacts[LENGTH(tags) + 1]; /* mfacts per tag */
++	unsigned int sellts[LENGTH(tags) + 1]; /* selected layouts */
++	const Layout *ltidxs[LENGTH(tags) + 1][2]; /* matrix of tags and layouts indexes  */
++	int showbars[LENGTH(tags) + 1]; /* display bar for the current tag */
++};
++
+ /* compile-time check if all tags fit into an unsigned int bit array. */
+ struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1 : 1]; };
+ 
+@@ -632,6 +643,7 @@ Monitor *
+ createmon(void)
+ {
+ 	Monitor *m;
++	unsigned int i;
+ 
+ 	m = ecalloc(1, sizeof(Monitor));
+ 	m->tagset[0] = m->tagset[1] = 1;
+@@ -642,6 +654,20 @@ createmon(void)
+ 	m->lt[0] = &layouts[0];
+ 	m->lt[1] = &layouts[1 % LENGTH(layouts)];
+ 	strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol);
++	m->pertag = ecalloc(1, sizeof(Pertag));
++	m->pertag->curtag = m->pertag->prevtag = 1;
++
++	for (i = 0; i <= LENGTH(tags); i++) {
++		m->pertag->nmasters[i] = m->nmaster;
++		m->pertag->mfacts[i] = m->mfact;
++
++		m->pertag->ltidxs[i][0] = m->lt[0];
++		m->pertag->ltidxs[i][1] = m->lt[1];
++		m->pertag->sellts[i] = m->sellt;
++
++		m->pertag->showbars[i] = m->showbar;
++	}
++
+ 	return m;
+ }
+ 
+@@ -968,7 +994,7 @@ grabkeys(void)
+ void
+ incnmaster(const Arg *arg)
+ {
+-	selmon->nmaster = MAX(selmon->nmaster + arg->i, 0);
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag] = MAX(selmon->nmaster + arg->i, 0);
+ 	arrange(selmon);
+ }
+ 
+@@ -1503,9 +1529,9 @@ void
+ setlayout(const Arg *arg)
+ {
+ 	if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
+-		selmon->sellt ^= 1;
++		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag] ^= 1;
+ 	if (arg && arg->v)
+-		selmon->lt[selmon->sellt] = (Layout *)arg->v;
++		selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt] = (Layout *)arg->v;
+ 	strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
+ 	if (selmon->sel)
+ 		arrange(selmon);
+@@ -1524,7 +1550,7 @@ setmfact(const Arg *arg)
+ 	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
+ 	if (f < 0.1 || f > 0.9)
+ 		return;
+-	selmon->mfact = f;
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag] = f;
+ 	arrange(selmon);
+ }
+ 
+@@ -1701,7 +1727,7 @@ tile(Monitor *m)
+ void
+ togglebar(const Arg *arg)
+ {
+-	selmon->showbar = !selmon->showbar;
++	selmon->showbar = selmon->pertag->showbars[selmon->pertag->curtag] = !selmon->showbar;
+ 	updatebarpos(selmon);
+ 	XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
+ 	arrange(selmon);
+@@ -1740,9 +1766,33 @@ void
+ toggleview(const Arg *arg)
+ {
+ 	unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
++	int i;
+ 
+ 	if (newtagset) {
+ 		selmon->tagset[selmon->seltags] = newtagset;
++
++		if (newtagset == ~0) {
++			selmon->pertag->prevtag = selmon->pertag->curtag;
++			selmon->pertag->curtag = 0;
++		}
++
++		/* test if the user did not select the same tag */
++		if (!(newtagset & 1 << (selmon->pertag->curtag - 1))) {
++			selmon->pertag->prevtag = selmon->pertag->curtag;
++			for (i = 0; !(newtagset & 1 << i); i++) ;
++			selmon->pertag->curtag = i + 1;
++		}
++
++		/* apply settings for this view */
++		selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
++		selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
++		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++		selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
++		selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
++
++		if (selmon->showbar != selmon->pertag->showbars[selmon->pertag->curtag])
++			togglebar(NULL);
++
+ 		focus(NULL);
+ 		arrange(selmon);
+ 	}
+@@ -2036,11 +2086,37 @@ updatewmhints(Client *c)
+ void
+ view(const Arg *arg)
+ {
++	int i;
++	unsigned int tmptag;
++
+ 	if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
+ 		return;
+ 	selmon->seltags ^= 1; /* toggle sel tagset */
+-	if (arg->ui & TAGMASK)
++	if (arg->ui & TAGMASK) {
+ 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++
++		if (arg->ui == ~0)
++			selmon->pertag->curtag = 0;
++		else {
++			for (i = 0; !(arg->ui & 1 << i); i++) ;
++			selmon->pertag->curtag = i + 1;
++		}
++	} else {
++		tmptag = selmon->pertag->prevtag;
++		selmon->pertag->prevtag = selmon->pertag->curtag;
++		selmon->pertag->curtag = tmptag;
++	}
++
++	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
++	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
++	selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
++	selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
++	selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
++
++	if (selmon->showbar != selmon->pertag->showbars[selmon->pertag->curtag])
++		togglebar(NULL);
++
+ 	focus(NULL);
+ 	arrange(selmon);
+ }
diff --git a/suckless/dwm/dwm.c b/suckless/dwm/dwm.c
@@ -0,0 +1,2225 @@
+/* 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 ISVISIBLE(C)            ((C->tags & C->mon->tagset[C->mon->seltags]))
+#define LENGTH(X)               (sizeof X / sizeof X[0])
+#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, 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 oldx, oldy, oldw, oldh;
+	int basew, baseh, incw, inch, maxw, maxh, minw, minh;
+	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;
+	void (*func)(const Arg *);
+	const Arg arg;
+} Key;
+
+typedef struct {
+	const char *symbol;
+	void (*arrange)(Monitor *);
+} Layout;
+
+typedef struct Pertag Pertag;
+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  */
+	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];
+	Pertag *pertag;
+};
+
+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 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 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 *nexttiled(Client *c);
+static void pop(Client *);
+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 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 sigchld(int unused);
+static void spawn(const Arg *arg);
+static void tag(const Arg *arg);
+static void tagmon(const Arg *arg);
+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, 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, blw = 0;      /* bar geometry */
+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 running = 1;
+static Cur *cursor[CurLast];
+static Clr **scheme;
+static Display *dpy;
+static Drw *drw;
+static Monitor *mons, *selmon;
+static Window root, wmcheckwin;
+
+/* configuration, allows nested code to access above variables */
+#include "config.h"
+
+struct Pertag {
+	unsigned int curtag, prevtag; /* current and previous tag */
+	int nmasters[LENGTH(tags) + 1]; /* number of windows in master area */
+	float mfacts[LENGTH(tags) + 1]; /* mfacts per tag */
+	unsigned int sellts[LENGTH(tags) + 1]; /* selected layouts */
+	const Layout *ltidxs[LENGTH(tags) + 1][2]; /* matrix of tags and layouts indexes  */
+	int showbars[LENGTH(tags) + 1]; /* display bar for the current tag */
+};
+
+/* 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) {
+		/* 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
+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;
+		do
+			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 + blw)
+			click = ClkLtSymbol;
+		else if (ev->x > selmon->ww - TEXTW(stext))
+			click = ClkStatusText;
+		else
+			click = ClkWinTitle;
+	} 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]);
+	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;
+	unsigned int i;
+
+	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->lt[0] = &layouts[0];
+	m->lt[1] = &layouts[1 % LENGTH(layouts)];
+	strncpy(m->ltsymbol, layouts[0].symbol, sizeof m->ltsymbol);
+	m->pertag = ecalloc(1, sizeof(Pertag));
+	m->pertag->curtag = m->pertag->prevtag = 1;
+
+	for (i = 0; i <= LENGTH(tags); i++) {
+		m->pertag->nmasters[i] = m->nmaster;
+		m->pertag->mfacts[i] = m->mfact;
+
+		m->pertag->ltidxs[i][0] = m->lt[0];
+		m->pertag->ltidxs[i][1] = m->lt[1];
+		m->pertag->sellts[i] = m->sellt;
+
+		m->pertag->showbars[i] = m->showbar;
+	}
+
+	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, sw = 0;
+	int boxs = drw->fonts->h / 9;
+	int boxw = drw->fonts->h / 6 + 2;
+	unsigned int i, occ = 0, urg = 0;
+	Client *c;
+
+	/* 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]);
+		sw = TEXTW(stext) - lrpad + 2; /* 2px right padding */
+		drw_text(drw, m->ww - sw, 0, sw, bh, 0, stext, 0);
+	}
+
+	for (c = m->clients; c; c = c->next) {
+		occ |= c->tags;
+		if (c->isurgent)
+			urg |= c->tags;
+	}
+	x = 0;
+	for (i = 0; i < LENGTH(tags); i++) {
+		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);
+		if (occ & 1 << i)
+			drw_rect(drw, x + boxs, boxs, boxw, boxw,
+				m == selmon && selmon->sel && selmon->sel->tags & 1 << i,
+				urg & 1 << i);
+		x += w;
+	}
+	w = blw = 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 - sw - x) > bh) {
+		if (m->sel) {
+			drw_setscheme(drw, scheme[m == selmon ? SchemeSel : SchemeNorm]);
+			drw_text(drw, x, 0, w, bh, lrpad / 2, m->sel->name, 0);
+			if (m->sel->isfloating)
+				drw_rect(drw, x + boxs, boxs, boxw, boxw, m->sel->isfixed, 0);
+		} else {
+			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)
+		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;
+		unsigned int modifiers[] = { 0, LockMask, numlockmask, numlockmask|LockMask };
+		KeyCode code;
+
+		XUngrabKey(dpy, AnyKey, AnyModifier, root);
+		for (i = 0; i < LENGTH(keys); i++)
+			if ((code = XKeysymToKeycode(dpy, keys[i].keysym)))
+				for (j = 0; j < LENGTH(modifiers); j++)
+					XGrabKey(dpy, code, keys[i].mod | modifiers[j], root,
+						True, GrabModeAsync, GrabModeAsync);
+	}
+}
+
+void
+incnmaster(const Arg *arg)
+{
+	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag] = 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;
+	KeySym keysym;
+	XKeyEvent *ev;
+
+	ev = &e->xkey;
+	keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
+	for (i = 0; i < LENGTH(keys); i++)
+		if (keysym == keys[i].keysym
+		&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
+		&& keys[i].func)
+			keys[i].func(&(keys[i].arg));
+}
+
+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->mx + c->mon->mw)
+		c->x = c->mon->mx + c->mon->mw - WIDTH(c);
+	if (c->y + HEIGHT(c) > c->mon->my + c->mon->mh)
+		c->y = c->mon->my + c->mon->mh - HEIGHT(c);
+	c->x = MAX(c->x, c->mon->mx);
+	/* only fix client y-offset, if the client center might cover the bar */
+	c->y = MAX(c->y, ((c->mon->by == c->mon->my) && (c->x + (c->w / 2) >= c->mon->wx)
+		&& (c->x + (c->w / 2) < c->mon->wx + c->mon->ww)) ? bh : c->mon->my);
+	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);
+	attach(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))
+		return;
+	if (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 *
+nexttiled(Client *c)
+{
+	for (; c && (c->isfloating || !ISVISIBLE(c)); c = c->next);
+	return c;
+}
+
+void
+pop(Client *c)
+{
+	detach(c);
+	attach(c);
+	focus(c);
+	arrange(c->mon);
+}
+
+void
+propertynotify(XEvent *e)
+{
+	Client *c;
+	Window trans;
+	XPropertyEvent *ev = &e->xproperty;
+
+	if ((ev->window == root) && (ev->atom == XA_WM_NAME))
+		updatestatus();
+	else if (ev->state == PropertyDelete)
+		return; /* ignore */
+	else if ((c = wintoclient(ev->window))) {
+		switch(ev->atom) {
+		default: break;
+		case XA_WM_TRANSIENT_FOR:
+			if (!c->isfloating && (XGetTransientForHint(dpy, c->win, &trans)) &&
+				(c->isfloating = (wintoclient(trans)) != NULL))
+				arrange(c->mon);
+			break;
+		case XA_WM_NORMAL_HINTS:
+			updatesizehints(c);
+			break;
+		case XA_WM_HINTS:
+			updatewmhints(c);
+			drawbars();
+			break;
+		}
+		if (ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) {
+			updatetitle(c);
+			if (c == c->mon->sel)
+				drawbar(c->mon);
+		}
+		if (ev->atom == netatom[NetWMWindowType])
+			updatewindowtype(c);
+	}
+}
+
+void
+quit(const Arg *arg)
+{
+	running = 0;
+}
+
+Monitor *
+recttomon(int x, int y, int w, int h)
+{
+	Monitor *m, *r = selmon;
+	int a, area = 0;
+
+	for (m = mons; m; m = m->next)
+		if ((a = INTERSECT(x, y, w, h, m)) > area) {
+			area = a;
+			r = m;
+		}
+	return r;
+}
+
+void
+resize(Client *c, int x, int y, int w, int h, int interact)
+{
+	if (applysizehints(c, &x, &y, &w, &h, interact))
+		resizeclient(c, x, y, w, h);
+}
+
+void
+resizeclient(Client *c, int x, int y, int w, int h)
+{
+	XWindowChanges wc;
+
+	c->oldx = c->x; c->x = wc.x = x;
+	c->oldy = c->y; c->y = wc.y = y;
+	c->oldw = c->w; c->w = wc.width = w;
+	c->oldh = c->h; c->h = wc.height = h;
+	wc.border_width = c->bw;
+	XConfigureWindow(dpy, c->win, CWX|CWY|CWWidth|CWHeight|CWBorderWidth, &wc);
+	configure(c);
+	XSync(dpy, False);
+}
+
+void
+resizemouse(const Arg *arg)
+{
+	int ocx, ocy, nw, nh;
+	Client *c;
+	Monitor *m;
+	XEvent ev;
+	Time lasttime = 0;
+
+	if (!(c = selmon->sel))
+		return;
+	if (c->isfullscreen) /* no support resizing fullscreen windows by mouse */
+		return;
+	restack(selmon);
+	ocx = c->x;
+	ocy = c->y;
+	if (XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
+		None, cursor[CurResize]->cursor, CurrentTime) != GrabSuccess)
+		return;
+	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1);
+	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;
+
+			nw = MAX(ev.xmotion.x - ocx - 2 * c->bw + 1, 1);
+			nh = MAX(ev.xmotion.y - ocy - 2 * c->bw + 1, 1);
+			if (c->mon->wx + nw >= selmon->wx && c->mon->wx + nw <= selmon->wx + selmon->ww
+			&& c->mon->wy + nh >= selmon->wy && c->mon->wy + nh <= selmon->wy + selmon->wh)
+			{
+				if (!c->isfloating && selmon->lt[selmon->sellt]->arrange
+				&& (abs(nw - c->w) > snap || abs(nh - c->h) > snap))
+					togglefloating(NULL);
+			}
+			if (!selmon->lt[selmon->sellt]->arrange || c->isfloating)
+				resize(c, c->x, c->y, nw, nh, 1);
+			break;
+		}
+	} while (ev.type != ButtonRelease);
+	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1);
+	XUngrabPointer(dpy, CurrentTime);
+	while (XCheckMaskEvent(dpy, EnterWindowMask, &ev));
+	if ((m = recttomon(c->x, c->y, c->w, c->h)) != selmon) {
+		sendmon(c, m);
+		selmon = m;
+		focus(NULL);
+	}
+}
+
+void
+restack(Monitor *m)
+{
+	Client *c;
+	XEvent ev;
+	XWindowChanges wc;
+
+	drawbar(m);
+	if (!m->sel)
+		return;
+	if (m->sel->isfloating || !m->lt[m->sellt]->arrange)
+		XRaiseWindow(dpy, m->sel->win);
+	if (m->lt[m->sellt]->arrange) {
+		wc.stack_mode = Below;
+		wc.sibling = m->barwin;
+		for (c = m->stack; c; c = c->snext)
+			if (!c->isfloating && ISVISIBLE(c)) {
+				XConfigureWindow(dpy, c->win, CWSibling|CWStackMode, &wc);
+				wc.sibling = c->win;
+			}
+	}
+	XSync(dpy, False);
+	while (XCheckMaskEvent(dpy, EnterWindowMask, &ev));
+}
+
+void
+run(void)
+{
+	XEvent ev;
+	/* main event loop */
+	XSync(dpy, False);
+	while (running && !XNextEvent(dpy, &ev))
+		if (handler[ev.type])
+			handler[ev.type](&ev); /* call handler */
+}
+
+void
+scan(void)
+{
+	unsigned int i, num;
+	Window d1, d2, *wins = NULL;
+	XWindowAttributes wa;
+
+	if (XQueryTree(dpy, root, &d1, &d2, &wins, &num)) {
+		for (i = 0; i < num; i++) {
+			if (!XGetWindowAttributes(dpy, wins[i], &wa)
+			|| wa.override_redirect || XGetTransientForHint(dpy, wins[i], &d1))
+				continue;
+			if (wa.map_state == IsViewable || getstate(wins[i]) == IconicState)
+				manage(wins[i], &wa);
+		}
+		for (i = 0; i < num; i++) { /* now the transients */
+			if (!XGetWindowAttributes(dpy, wins[i], &wa))
+				continue;
+			if (XGetTransientForHint(dpy, wins[i], &d1)
+			&& (wa.map_state == IsViewable || getstate(wins[i]) == IconicState))
+				manage(wins[i], &wa);
+		}
+		if (wins)
+			XFree(wins);
+	}
+}
+
+void
+sendmon(Client *c, Monitor *m)
+{
+	if (c->mon == m)
+		return;
+	unfocus(c, 1);
+	detach(c);
+	detachstack(c);
+	c->mon = m;
+	c->tags = m->tagset[m->seltags]; /* assign tags of target monitor */
+	attach(c);
+	attachstack(c);
+	focus(NULL);
+	arrange(NULL);
+}
+
+void
+setclientstate(Client *c, long state)
+{
+	long data[] = { state, None };
+
+	XChangeProperty(dpy, c->win, wmatom[WMState], wmatom[WMState], 32,
+		PropModeReplace, (unsigned char *)data, 2);
+}
+
+int
+sendevent(Client *c, Atom proto)
+{
+	int n;
+	Atom *protocols;
+	int exists = 0;
+	XEvent ev;
+
+	if (XGetWMProtocols(dpy, c->win, &protocols, &n)) {
+		while (!exists && n--)
+			exists = protocols[n] == proto;
+		XFree(protocols);
+	}
+	if (exists) {
+		ev.type = ClientMessage;
+		ev.xclient.window = c->win;
+		ev.xclient.message_type = wmatom[WMProtocols];
+		ev.xclient.format = 32;
+		ev.xclient.data.l[0] = proto;
+		ev.xclient.data.l[1] = CurrentTime;
+		XSendEvent(dpy, c->win, False, NoEventMask, &ev);
+	}
+	return exists;
+}
+
+void
+setfocus(Client *c)
+{
+	if (!c->neverfocus) {
+		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
+		XChangeProperty(dpy, root, netatom[NetActiveWindow],
+			XA_WINDOW, 32, PropModeReplace,
+			(unsigned char *) &(c->win), 1);
+	}
+	sendevent(c, wmatom[WMTakeFocus]);
+}
+
+void
+setfullscreen(Client *c, int fullscreen)
+{
+	if (fullscreen && !c->isfullscreen) {
+		XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32,
+			PropModeReplace, (unsigned char*)&netatom[NetWMFullscreen], 1);
+		c->isfullscreen = 1;
+		c->oldstate = c->isfloating;
+		c->oldbw = c->bw;
+		c->bw = 0;
+		c->isfloating = 1;
+		resizeclient(c, c->mon->mx, c->mon->my, c->mon->mw, c->mon->mh);
+		XRaiseWindow(dpy, c->win);
+	} else if (!fullscreen && c->isfullscreen){
+		XChangeProperty(dpy, c->win, netatom[NetWMState], XA_ATOM, 32,
+			PropModeReplace, (unsigned char*)0, 0);
+		c->isfullscreen = 0;
+		c->isfloating = c->oldstate;
+		c->bw = c->oldbw;
+		c->x = c->oldx;
+		c->y = c->oldy;
+		c->w = c->oldw;
+		c->h = c->oldh;
+		resizeclient(c, c->x, c->y, c->w, c->h);
+		arrange(c->mon);
+	}
+}
+
+void
+setlayout(const Arg *arg)
+{
+	if (!arg || !arg->v || arg->v != selmon->lt[selmon->sellt])
+		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag] ^= 1;
+	if (arg && arg->v)
+		selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt] = (Layout *)arg->v;
+	strncpy(selmon->ltsymbol, selmon->lt[selmon->sellt]->symbol, sizeof selmon->ltsymbol);
+	if (selmon->sel)
+		arrange(selmon);
+	else
+		drawbar(selmon);
+}
+
+/* arg > 1.0 will set mfact absolutely */
+void
+setmfact(const Arg *arg)
+{
+	float f;
+
+	if (!arg || !selmon->lt[selmon->sellt]->arrange)
+		return;
+	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
+	if (f < 0.1 || f > 0.9)
+		return;
+	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag] = f;
+	arrange(selmon);
+}
+
+void
+setup(void)
+{
+	int i;
+	XSetWindowAttributes wa;
+	Atom utf8string;
+
+	/* clean up any zombies immediately */
+	sigchld(0);
+
+	/* init screen */
+	screen = DefaultScreen(dpy);
+	sw = DisplayWidth(dpy, screen);
+	sh = DisplayHeight(dpy, screen);
+	root = RootWindow(dpy, screen);
+	drw = drw_create(dpy, screen, root, sw, sh);
+	if (!drw_fontset_create(drw, fonts, LENGTH(fonts)))
+		die("no fonts could be loaded.");
+	lrpad = drw->fonts->h;
+	bh = drw->fonts->h + 2;
+	updategeom();
+	/* init atoms */
+	utf8string = XInternAtom(dpy, "UTF8_STRING", False);
+	wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);
+	wmatom[WMDelete] = XInternAtom(dpy, "WM_DELETE_WINDOW", False);
+	wmatom[WMState] = XInternAtom(dpy, "WM_STATE", False);
+	wmatom[WMTakeFocus] = XInternAtom(dpy, "WM_TAKE_FOCUS", False);
+	netatom[NetActiveWindow] = XInternAtom(dpy, "_NET_ACTIVE_WINDOW", False);
+	netatom[NetSupported] = XInternAtom(dpy, "_NET_SUPPORTED", False);
+	netatom[NetWMName] = XInternAtom(dpy, "_NET_WM_NAME", False);
+	netatom[NetWMState] = XInternAtom(dpy, "_NET_WM_STATE", False);
+	netatom[NetWMCheck] = XInternAtom(dpy, "_NET_SUPPORTING_WM_CHECK", False);
+	netatom[NetWMFullscreen] = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN", False);
+	netatom[NetWMWindowType] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE", False);
+	netatom[NetWMWindowTypeDialog] = XInternAtom(dpy, "_NET_WM_WINDOW_TYPE_DIALOG", False);
+	netatom[NetClientList] = XInternAtom(dpy, "_NET_CLIENT_LIST", False);
+	/* init cursors */
+	cursor[CurNormal] = drw_cur_create(drw, XC_left_ptr);
+	cursor[CurResize] = drw_cur_create(drw, XC_sizing);
+	cursor[CurMove] = drw_cur_create(drw, XC_fleur);
+	/* init appearance */
+	scheme = ecalloc(LENGTH(colors), sizeof(Clr *));
+	for (i = 0; i < LENGTH(colors); i++)
+		scheme[i] = drw_scm_create(drw, colors[i], 3);
+	/* init bars */
+	updatebars();
+	updatestatus();
+	/* supporting window for NetWMCheck */
+	wmcheckwin = XCreateSimpleWindow(dpy, root, 0, 0, 1, 1, 0, 0, 0);
+	XChangeProperty(dpy, wmcheckwin, netatom[NetWMCheck], XA_WINDOW, 32,
+		PropModeReplace, (unsigned char *) &wmcheckwin, 1);
+	XChangeProperty(dpy, wmcheckwin, netatom[NetWMName], utf8string, 8,
+		PropModeReplace, (unsigned char *) "dwm", 3);
+	XChangeProperty(dpy, root, netatom[NetWMCheck], XA_WINDOW, 32,
+		PropModeReplace, (unsigned char *) &wmcheckwin, 1);
+	/* EWMH support per view */
+	XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
+		PropModeReplace, (unsigned char *) netatom, NetLast);
+	XDeleteProperty(dpy, root, netatom[NetClientList]);
+	/* select events */
+	wa.cursor = cursor[CurNormal]->cursor;
+	wa.event_mask = SubstructureRedirectMask|SubstructureNotifyMask
+		|ButtonPressMask|PointerMotionMask|EnterWindowMask
+		|LeaveWindowMask|StructureNotifyMask|PropertyChangeMask;
+	XChangeWindowAttributes(dpy, root, CWEventMask|CWCursor, &wa);
+	XSelectInput(dpy, root, wa.event_mask);
+	grabkeys();
+	focus(NULL);
+}
+
+
+void
+seturgent(Client *c, int urg)
+{
+	XWMHints *wmh;
+
+	c->isurgent = urg;
+	if (!(wmh = XGetWMHints(dpy, c->win)))
+		return;
+	wmh->flags = urg ? (wmh->flags | XUrgencyHint) : (wmh->flags & ~XUrgencyHint);
+	XSetWMHints(dpy, c->win, wmh);
+	XFree(wmh);
+}
+
+void
+showhide(Client *c)
+{
+	if (!c)
+		return;
+	if (ISVISIBLE(c)) {
+		/* show clients top down */
+		XMoveWindow(dpy, c->win, c->x, c->y);
+		if ((!c->mon->lt[c->mon->sellt]->arrange || c->isfloating) && !c->isfullscreen)
+			resize(c, c->x, c->y, c->w, c->h, 0);
+		showhide(c->snext);
+	} else {
+		/* hide clients bottom up */
+		showhide(c->snext);
+		XMoveWindow(dpy, c->win, WIDTH(c) * -2, c->y);
+	}
+}
+
+void
+sigchld(int unused)
+{
+	if (signal(SIGCHLD, sigchld) == SIG_ERR)
+		die("can't install SIGCHLD handler:");
+	while (0 < waitpid(-1, NULL, WNOHANG));
+}
+
+void
+spawn(const Arg *arg)
+{
+	if (arg->v == dmenucmd)
+		dmenumon[0] = '0' + selmon->num;
+	if (fork() == 0) {
+		if (dpy)
+			close(ConnectionNumber(dpy));
+		setsid();
+		execvp(((char **)arg->v)[0], (char **)arg->v);
+		fprintf(stderr, "dwm: execvp %s", ((char **)arg->v)[0]);
+		perror(" failed");
+		exit(EXIT_SUCCESS);
+	}
+}
+
+void
+tag(const Arg *arg)
+{
+	if (selmon->sel && arg->ui & TAGMASK) {
+		selmon->sel->tags = arg->ui & TAGMASK;
+		focus(NULL);
+		arrange(selmon);
+	}
+}
+
+void
+tagmon(const Arg *arg)
+{
+	if (!selmon->sel || !mons->next)
+		return;
+	sendmon(selmon->sel, dirtomon(arg->i));
+}
+
+void
+tile(Monitor *m)
+{
+	unsigned int i, n, h, mw, my, ty;
+	Client *c;
+
+	for (n = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), n++);
+	if (n == 0)
+		return;
+
+	if (n > m->nmaster)
+		mw = m->nmaster ? m->ww * m->mfact : 0;
+	else
+		mw = m->ww;
+	for (i = my = ty = 0, c = nexttiled(m->clients); c; c = nexttiled(c->next), i++)
+		if (i < m->nmaster) {
+			h = (m->wh - my) / (MIN(n, m->nmaster) - i);
+			resize(c, m->wx, m->wy + my, mw - (2*c->bw), h - (2*c->bw), 0);
+			my += HEIGHT(c);
+		} else {
+			h = (m->wh - ty) / (n - i);
+			resize(c, m->wx + mw, m->wy + ty, m->ww - mw - (2*c->bw), h - (2*c->bw), 0);
+			ty += HEIGHT(c);
+		}
+}
+
+void
+togglebar(const Arg *arg)
+{
+	selmon->showbar = selmon->pertag->showbars[selmon->pertag->curtag] = !selmon->showbar;
+	updatebarpos(selmon);
+	XMoveResizeWindow(dpy, selmon->barwin, selmon->wx, selmon->by, selmon->ww, bh);
+	arrange(selmon);
+}
+
+void
+togglefloating(const Arg *arg)
+{
+	if (!selmon->sel)
+		return;
+	if (selmon->sel->isfullscreen) /* no support for fullscreen windows */
+		return;
+	selmon->sel->isfloating = !selmon->sel->isfloating || selmon->sel->isfixed;
+	if (selmon->sel->isfloating)
+		resize(selmon->sel, selmon->sel->x, selmon->sel->y,
+			selmon->sel->w, selmon->sel->h, 0);
+	arrange(selmon);
+}
+
+void
+toggletag(const Arg *arg)
+{
+	unsigned int newtags;
+
+	if (!selmon->sel)
+		return;
+	newtags = selmon->sel->tags ^ (arg->ui & TAGMASK);
+	if (newtags) {
+		selmon->sel->tags = newtags;
+		focus(NULL);
+		arrange(selmon);
+	}
+}
+
+void
+toggleview(const Arg *arg)
+{
+	unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
+	int i;
+
+	if (newtagset) {
+		selmon->tagset[selmon->seltags] = newtagset;
+
+		if (newtagset == ~0) {
+			selmon->pertag->prevtag = selmon->pertag->curtag;
+			selmon->pertag->curtag = 0;
+		}
+
+		/* test if the user did not select the same tag */
+		if (!(newtagset & 1 << (selmon->pertag->curtag - 1))) {
+			selmon->pertag->prevtag = selmon->pertag->curtag;
+			for (i = 0; !(newtagset & 1 << i); i++) ;
+			selmon->pertag->curtag = i + 1;
+		}
+
+		/* apply settings for this view */
+		selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
+		selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
+		selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
+		selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
+		selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
+
+		if (selmon->showbar != selmon->pertag->showbars[selmon->pertag->curtag])
+			togglebar(NULL);
+
+		focus(NULL);
+		arrange(selmon);
+	}
+}
+
+void
+unfocus(Client *c, int setfocus)
+{
+	if (!c)
+		return;
+	grabbuttons(c, 0);
+	XSetWindowBorder(dpy, c->win, scheme[SchemeNorm][ColBorder].pixel);
+	if (setfocus) {
+		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
+		XDeleteProperty(dpy, root, netatom[NetActiveWindow]);
+	}
+}
+
+void
+unmanage(Client *c, int destroyed)
+{
+	Monitor *m = c->mon;
+	XWindowChanges wc;
+
+	detach(c);
+	detachstack(c);
+	if (!destroyed) {
+		wc.border_width = c->oldbw;
+		XGrabServer(dpy); /* avoid race conditions */
+		XSetErrorHandler(xerrordummy);
+		XConfigureWindow(dpy, c->win, CWBorderWidth, &wc); /* restore border */
+		XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
+		setclientstate(c, WithdrawnState);
+		XSync(dpy, False);
+		XSetErrorHandler(xerror);
+		XUngrabServer(dpy);
+	}
+	free(c);
+	focus(NULL);
+	updateclientlist();
+	arrange(m);
+}
+
+void
+unmapnotify(XEvent *e)
+{
+	Client *c;
+	XUnmapEvent *ev = &e->xunmap;
+
+	if ((c = wintoclient(ev->window))) {
+		if (ev->send_event)
+			setclientstate(c, WithdrawnState);
+		else
+			unmanage(c, 0);
+	}
+}
+
+void
+updatebars(void)
+{
+	Monitor *m;
+	XSetWindowAttributes wa = {
+		.override_redirect = True,
+		.background_pixmap = ParentRelative,
+		.event_mask = ButtonPressMask|ExposureMask
+	};
+	XClassHint ch = {"dwm", "dwm"};
+	for (m = mons; m; m = m->next) {
+		if (m->barwin)
+			continue;
+		m->barwin = XCreateWindow(dpy, root, m->wx, m->by, m->ww, bh, 0, DefaultDepth(dpy, screen),
+				CopyFromParent, DefaultVisual(dpy, screen),
+				CWOverrideRedirect|CWBackPixmap|CWEventMask, &wa);
+		XDefineCursor(dpy, m->barwin, cursor[CurNormal]->cursor);
+		XMapRaised(dpy, m->barwin);
+		XSetClassHint(dpy, m->barwin, &ch);
+	}
+}
+
+void
+updatebarpos(Monitor *m)
+{
+	m->wy = m->my;
+	m->wh = m->mh;
+	if (m->showbar) {
+		m->wh -= bh;
+		m->by = m->topbar ? m->wy : m->wy + m->wh;
+		m->wy = m->topbar ? m->wy + bh : m->wy;
+	} else
+		m->by = -bh;
+}
+
+void
+updateclientlist()
+{
+	Client *c;
+	Monitor *m;
+
+	XDeleteProperty(dpy, root, netatom[NetClientList]);
+	for (m = mons; m; m = m->next)
+		for (c = m->clients; c; c = c->next)
+			XChangeProperty(dpy, root, netatom[NetClientList],
+				XA_WINDOW, 32, PropModeAppend,
+				(unsigned char *) &(c->win), 1);
+}
+
+int
+updategeom(void)
+{
+	int dirty = 0;
+
+#ifdef XINERAMA
+	if (XineramaIsActive(dpy)) {
+		int i, j, n, nn;
+		Client *c;
+		Monitor *m;
+		XineramaScreenInfo *info = XineramaQueryScreens(dpy, &nn);
+		XineramaScreenInfo *unique = NULL;
+
+		for (n = 0, m = mons; m; m = m->next, n++);
+		/* only consider unique geometries as separate screens */
+		unique = ecalloc(nn, sizeof(XineramaScreenInfo));
+		for (i = 0, j = 0; i < nn; i++)
+			if (isuniquegeom(unique, j, &info[i]))
+				memcpy(&unique[j++], &info[i], sizeof(XineramaScreenInfo));
+		XFree(info);
+		nn = j;
+		if (n <= nn) { /* new monitors available */
+			for (i = 0; i < (nn - n); i++) {
+				for (m = mons; m && m->next; m = m->next);
+				if (m)
+					m->next = createmon();
+				else
+					mons = createmon();
+			}
+			for (i = 0, m = mons; i < nn && m; m = m->next, i++)
+				if (i >= n
+				|| unique[i].x_org != m->mx || unique[i].y_org != m->my
+				|| unique[i].width != m->mw || unique[i].height != m->mh)
+				{
+					dirty = 1;
+					m->num = i;
+					m->mx = m->wx = unique[i].x_org;
+					m->my = m->wy = unique[i].y_org;
+					m->mw = m->ww = unique[i].width;
+					m->mh = m->wh = unique[i].height;
+					updatebarpos(m);
+				}
+		} else { /* less monitors available nn < n */
+			for (i = nn; i < n; i++) {
+				for (m = mons; m && m->next; m = m->next);
+				while ((c = m->clients)) {
+					dirty = 1;
+					m->clients = c->next;
+					detachstack(c);
+					c->mon = mons;
+					attach(c);
+					attachstack(c);
+				}
+				if (m == selmon)
+					selmon = mons;
+				cleanupmon(m);
+			}
+		}
+		free(unique);
+	} else
+#endif /* XINERAMA */
+	{ /* default monitor setup */
+		if (!mons)
+			mons = createmon();
+		if (mons->mw != sw || mons->mh != sh) {
+			dirty = 1;
+			mons->mw = mons->ww = sw;
+			mons->mh = mons->wh = sh;
+			updatebarpos(mons);
+		}
+	}
+	if (dirty) {
+		selmon = mons;
+		selmon = wintomon(root);
+	}
+	return dirty;
+}
+
+void
+updatenumlockmask(void)
+{
+	unsigned int i, j;
+	XModifierKeymap *modmap;
+
+	numlockmask = 0;
+	modmap = XGetModifierMapping(dpy);
+	for (i = 0; i < 8; i++)
+		for (j = 0; j < modmap->max_keypermod; j++)
+			if (modmap->modifiermap[i * modmap->max_keypermod + j]
+				== XKeysymToKeycode(dpy, XK_Num_Lock))
+				numlockmask = (1 << i);
+	XFreeModifiermap(modmap);
+}
+
+void
+updatesizehints(Client *c)
+{
+	long msize;
+	XSizeHints size;
+
+	if (!XGetWMNormalHints(dpy, c->win, &size, &msize))
+		/* size is uninitialized, ensure that size.flags aren't used */
+		size.flags = PSize;
+	if (size.flags & PBaseSize) {
+		c->basew = size.base_width;
+		c->baseh = size.base_height;
+	} else if (size.flags & PMinSize) {
+		c->basew = size.min_width;
+		c->baseh = size.min_height;
+	} else
+		c->basew = c->baseh = 0;
+	if (size.flags & PResizeInc) {
+		c->incw = size.width_inc;
+		c->inch = size.height_inc;
+	} else
+		c->incw = c->inch = 0;
+	if (size.flags & PMaxSize) {
+		c->maxw = size.max_width;
+		c->maxh = size.max_height;
+	} else
+		c->maxw = c->maxh = 0;
+	if (size.flags & PMinSize) {
+		c->minw = size.min_width;
+		c->minh = size.min_height;
+	} else if (size.flags & PBaseSize) {
+		c->minw = size.base_width;
+		c->minh = size.base_height;
+	} else
+		c->minw = c->minh = 0;
+	if (size.flags & PAspect) {
+		c->mina = (float)size.min_aspect.y / size.min_aspect.x;
+		c->maxa = (float)size.max_aspect.x / size.max_aspect.y;
+	} else
+		c->maxa = c->mina = 0.0;
+	c->isfixed = (c->maxw && c->maxh && c->maxw == c->minw && c->maxh == c->minh);
+}
+
+void
+updatestatus(void)
+{
+	if (!gettextprop(root, XA_WM_NAME, stext, sizeof(stext)))
+		strcpy(stext, "dwm-"VERSION);
+	drawbar(selmon);
+}
+
+void
+updatetitle(Client *c)
+{
+	if (!gettextprop(c->win, netatom[NetWMName], c->name, sizeof c->name))
+		gettextprop(c->win, XA_WM_NAME, c->name, sizeof c->name);
+	if (c->name[0] == '\0') /* hack to mark broken clients */
+		strcpy(c->name, broken);
+}
+
+void
+updatewindowtype(Client *c)
+{
+	Atom state = getatomprop(c, netatom[NetWMState]);
+	Atom wtype = getatomprop(c, netatom[NetWMWindowType]);
+
+	if (state == netatom[NetWMFullscreen])
+		setfullscreen(c, 1);
+	if (wtype == netatom[NetWMWindowTypeDialog])
+		c->isfloating = 1;
+}
+
+void
+updatewmhints(Client *c)
+{
+	XWMHints *wmh;
+
+	if ((wmh = XGetWMHints(dpy, c->win))) {
+		if (c == selmon->sel && wmh->flags & XUrgencyHint) {
+			wmh->flags &= ~XUrgencyHint;
+			XSetWMHints(dpy, c->win, wmh);
+		} else
+			c->isurgent = (wmh->flags & XUrgencyHint) ? 1 : 0;
+		if (wmh->flags & InputHint)
+			c->neverfocus = !wmh->input;
+		else
+			c->neverfocus = 0;
+		XFree(wmh);
+	}
+}
+
+void
+view(const Arg *arg)
+{
+	int i;
+	unsigned int tmptag;
+
+	if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
+		return;
+	selmon->seltags ^= 1; /* toggle sel tagset */
+	if (arg->ui & TAGMASK) {
+		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
+		selmon->pertag->prevtag = selmon->pertag->curtag;
+
+		if (arg->ui == ~0)
+			selmon->pertag->curtag = 0;
+		else {
+			for (i = 0; !(arg->ui & 1 << i); i++) ;
+			selmon->pertag->curtag = i + 1;
+		}
+	} else {
+		tmptag = selmon->pertag->prevtag;
+		selmon->pertag->prevtag = selmon->pertag->curtag;
+		selmon->pertag->curtag = tmptag;
+	}
+
+	selmon->nmaster = selmon->pertag->nmasters[selmon->pertag->curtag];
+	selmon->mfact = selmon->pertag->mfacts[selmon->pertag->curtag];
+	selmon->sellt = selmon->pertag->sellts[selmon->pertag->curtag];
+	selmon->lt[selmon->sellt] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt];
+	selmon->lt[selmon->sellt^1] = selmon->pertag->ltidxs[selmon->pertag->curtag][selmon->sellt^1];
+
+	if (selmon->showbar != selmon->pertag->showbars[selmon->pertag->curtag])
+		togglebar(NULL);
+
+	focus(NULL);
+	arrange(selmon);
+}
+
+Client *
+wintoclient(Window w)
+{
+	Client *c;
+	Monitor *m;
+
+	for (m = mons; m; m = m->next)
+		for (c = m->clients; c; c = c->next)
+			if (c->win == w)
+				return c;
+	return NULL;
+}
+
+Monitor *
+wintomon(Window w)
+{
+	int x, y;
+	Client *c;
+	Monitor *m;
+
+	if (w == root && getrootptr(&x, &y))
+		return recttomon(x, y, 1, 1);
+	for (m = mons; m; m = m->next)
+		if (w == m->barwin)
+			return m;
+	if ((c = wintoclient(w)))
+		return c->mon;
+	return selmon;
+}
+
+/* There's no way to check accesses to destroyed windows, thus those cases are
+ * ignored (especially on UnmapNotify's). Other types of errors call Xlibs
+ * default error handler, which may call exit. */
+int
+xerror(Display *dpy, XErrorEvent *ee)
+{
+	if (ee->error_code == BadWindow
+	|| (ee->request_code == X_SetInputFocus && ee->error_code == BadMatch)
+	|| (ee->request_code == X_PolyText8 && ee->error_code == BadDrawable)
+	|| (ee->request_code == X_PolyFillRectangle && ee->error_code == BadDrawable)
+	|| (ee->request_code == X_PolySegment && ee->error_code == BadDrawable)
+	|| (ee->request_code == X_ConfigureWindow && ee->error_code == BadMatch)
+	|| (ee->request_code == X_GrabButton && ee->error_code == BadAccess)
+	|| (ee->request_code == X_GrabKey && ee->error_code == BadAccess)
+	|| (ee->request_code == X_CopyArea && ee->error_code == BadDrawable))
+		return 0;
+	fprintf(stderr, "dwm: fatal error: request code=%d, error code=%d\n",
+		ee->request_code, ee->error_code);
+	return xerrorxlib(dpy, ee); /* may call exit */
+}
+
+int
+xerrordummy(Display *dpy, XErrorEvent *ee)
+{
+	return 0;
+}
+
+/* Startup Error handler to check if another window manager
+ * is already running. */
+int
+xerrorstart(Display *dpy, XErrorEvent *ee)
+{
+	die("dwm: another window manager is already running");
+	return -1;
+}
+
+void
+zoom(const Arg *arg)
+{
+	Client *c = selmon->sel;
+
+	if (!selmon->lt[selmon->sellt]->arrange
+	|| (selmon->sel && selmon->sel->isfloating))
+		return;
+	if (c == nexttiled(selmon->clients))
+		if (!c || !(c = nexttiled(c->next)))
+			return;
+	pop(c);
+}
+
+int
+main(int argc, char *argv[])
+{
+	if (argc == 2 && !strcmp("-v", argv[1]))
+		die("dwm-"VERSION);
+	else if (argc != 1)
+		die("usage: dwm [-v]");
+	if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
+		fputs("warning: no locale support\n", stderr);
+	if (!(dpy = XOpenDisplay(NULL)))
+		die("dwm: cannot open display");
+	checkotherwm();
+	setup();
+#ifdef __OpenBSD__
+	if (pledge("stdio rpath proc exec", NULL) == -1)
+		die("pledge");
+#endif /* __OpenBSD__ */
+	scan();
+	run();
+	cleanup();
+	XCloseDisplay(dpy);
+	return EXIT_SUCCESS;
+}
diff --git a/suckless/surf/config.def.h b/suckless/surf/config.def.h
@@ -0,0 +1,169 @@
+/* modifier 0 means no modifier */
+static int surfuseragent    = 1;  /* Append Surf version to default WebKit user agent */
+static char *fulluseragent  = ""; /* Or override the whole user agent string */
+static char *scriptfile     = "~/.surf/script.js";
+static char *styledir       = "~/.surf/styles/";
+static char *cachedir       = "~/.surf/cache/";
+static char *cookiefile     = "~/.surf/cookies.txt";
+
+/* Webkit default features */
+static Parameter defconfig[ParameterLast] = {
+	SETB(AcceleratedCanvas,  1),
+	SETB(CaretBrowsing,      0),
+	SETV(CookiePolicies,     "@Aa"),
+	SETB(DiskCache,          1),
+	SETB(DNSPrefetch,        0),
+	SETI(FontSize,           12),
+	SETB(FrameFlattening,    0),
+	SETB(Geolocation,        0),
+	SETB(HideBackground,     0),
+	SETB(Inspector,          0),
+	SETB(JavaScript,         1),
+	SETB(KioskMode,          0),
+	SETB(LoadImages,         1),
+	SETB(MediaManualPlay,    0),
+	SETB(Plugins,            1),
+	SETV(PreferredLanguages, ((char *[]){ NULL })),
+	SETB(RunInFullscreen,    0),
+	SETB(ScrollBars,         1),
+	SETB(ShowIndicators,     1),
+	SETB(SiteQuirks,         1),
+	SETB(SpellChecking,      0),
+	SETV(SpellLanguages,     ((char *[]){ "en_US", NULL })),
+	SETB(StrictSSL,          0),
+	SETB(Style,              1),
+	SETF(ZoomLevel,          1.0),
+};
+
+static UriParameters uriparams[] = {
+	{ "(://|\\.)suckless\\.org(/|$)", {
+	  FSETB(JavaScript, 0),
+	  FSETB(Plugins,    0),
+	}, },
+};
+
+static WebKitFindOptions findopts = WEBKIT_FIND_OPTIONS_CASE_INSENSITIVE |
+                                    WEBKIT_FIND_OPTIONS_WRAP_AROUND;
+
+#define SETPROP(p, q) { \
+        .v = (const char *[]){ "/bin/sh", "-c", \
+             "prop=\"`xprop -id $2 $0 " \
+             "| sed \"s/^$0(STRING) = \\(\\\\\"\\?\\)\\(.*\\)\\1$/\\2/\" " \
+             "| xargs -0 printf %b | dmenu`\" &&" \
+             "xprop -id $2 -f $1 8s -set $1 \"$prop\"", \
+             p, q, winid, NULL \
+        } \
+}
+
+/* DOWNLOAD(URI, referer) */
+#define DOWNLOAD(d, r) { \
+        .v = (const char *[]){ "/bin/sh", "-c", \
+             "st -e /bin/sh -c \"curl -g -L -J -O --user-agent '$1'" \
+             " --referer '$2' -b $3 -c $3 '$0';" \
+             " sleep 5;\"", \
+             d, useragent, r, cookiefile, NULL \
+        } \
+}
+
+/* PLUMB(URI) */
+/* This called when some URI which does not begin with "about:",
+ * "http://" or "https://" should be opened.
+ */
+#define PLUMB(u) {\
+        .v = (const char *[]){ "/bin/sh", "-c", \
+             "xdg-open \"$0\"", u, NULL \
+        } \
+}
+
+/* VIDEOPLAY(URI) */
+#define VIDEOPLAY(u) {\
+        .v = (const char *[]){ "/bin/sh", "-c", \
+             "mpv --really-quiet \"$0\"", u, NULL \
+        } \
+}
+
+/* styles */
+/*
+ * The iteration will stop at the first match, beginning at the beginning of
+ * the list.
+ */
+static SiteStyle styles[] = {
+	/* regexp               file in $styledir */
+	{ ".*",                 "default.css" },
+};
+
+#define MODKEY GDK_CONTROL_MASK
+
+/* hotkeys */
+/*
+ * If you use anything else but MODKEY and GDK_SHIFT_MASK, don't forget to
+ * edit the CLEANMASK() macro.
+ */
+static Key keys[] = {
+	/* modifier              keyval          function    arg */
+	{ 0,                GDK_KEY_g,      spawn,      SETPROP("_SURF_URI", "_SURF_GO") },
+	{ 0,                GDK_KEY_f,      spawn,      SETPROP("_SURF_FIND", "_SURF_FIND") },
+	{ 0,                GDK_KEY_slash,  spawn,      SETPROP("_SURF_FIND", "_SURF_FIND") },
+
+	{ 0,                GDK_KEY_i,      insert,       { .i = 1 } },
+	{ 0,                GDK_KEY_Escape, insert,       { .i = 0 } },
+
+	{ 0,                GDK_KEY_c,      stop,     { 0 } },
+
+	{ 0,                GDK_KEY_r,      reload,   { .i = 1 } },
+	{ 0,                GDK_KEY_r,      reload,   { .i = 0 } },
+
+	{ 0,                GDK_KEY_l,      navigate,   { .i = +1 } },
+	{ 0,                GDK_KEY_h,      navigate,   { .i = -1 } },
+
+	/* Currently we have to use scrolling steps that WebKit2GTK+ gives us
+	 * d: step down, u: step up, r: step right, l:step left
+	 * D: page down, U: page up */
+	{ 0,                GDK_KEY_j,      scroll,     { .i = 'd' } },
+	{ 0,                GDK_KEY_k,      scroll,     { .i = 'u' } },
+	{ 0,                GDK_KEY_b,      scroll,     { .i = 'U' } },
+	{ 0,                GDK_KEY_space,  scroll,     { .i = 'D' } },
+	{ 0,                GDK_KEY_i,      scroll,     { .i = 'r' } },
+	{ 0,                GDK_KEY_u,      scroll,     { .i = 'l' } },
+
+
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_j,      zoom,       { .i = -1 } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_k,      zoom,       { .i = +1 } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_q,      zoom,       { .i = 0  } },
+	{ 0,                GDK_KEY_minus,  zoom,       { .i = -1 } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_plus,   zoom,       { .i = +1 } },
+	{ 0,                GDK_KEY_equal,  zoom,       { .i = 0  } },
+
+	{ 0,                GDK_KEY_p,      clipboard,  { .b = 1 } },
+	{ 0,                GDK_KEY_y,      clipboard,  { .b = 0 } },
+
+	{ 0,                GDK_KEY_n,      find,       { .i = +1 } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_n,      find,       { .i = -1 } },
+
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_p,      print,      { 0 } },
+
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_a,      togglecookiepolicy, { 0 } },
+	{ 0,                     GDK_KEY_F11,    togglefullscreen, { 0 } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_o,      toggleinspector, { 0 } },
+
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_c,      toggle,     { .i = CaretBrowsing } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_f,      toggle,     { .i = FrameFlattening } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_g,      toggle,     { .i = Geolocation } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_s,      toggle,     { .i = JavaScript } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_i,      toggle,     { .i = LoadImages } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_v,      toggle,     { .i = Plugins } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_b,      toggle,     { .i = ScrollBars } },
+	{ 0|GDK_SHIFT_MASK, GDK_KEY_m,      toggle,     { .i = Style } },
+};
+
+/* button definitions */
+/* target can be OnDoc, OnLink, OnImg, OnMedia, OnEdit, OnBar, OnSel, OnAny */
+static Button buttons[] = {
+	/* target       event mask      button  function        argument        stop event */
+	{ OnLink,       0,              2,      clicknewwindow, { .b = 0 },     1 },
+	{ OnLink,       MODKEY,         2,      clicknewwindow, { .b = 1 },     1 },
+	{ OnLink,       MODKEY,         1,      clicknewwindow, { .b = 1 },     1 },
+	{ OnAny,        0,              8,      clicknavigate,  { .i = -1 },    1 },
+	{ OnAny,        0,              9,      clicknavigate,  { .i = +1 },    1 },
+	{ OnMedia,      MODKEY,         1,      clickexternplayer, { 0 },       1 },
+};
diff --git a/suckless/surf/surf-git-20170323-webkit2-searchengines.diff b/suckless/surf/surf-git-20170323-webkit2-searchengines.diff
@@ -0,0 +1,56 @@
+diff --git a/surf.c b/surf.c
+index 93a1629..eb2af97 100644
+--- a/surf.c
++++ b/surf.c
+@@ -129,6 +129,11 @@ typedef struct {
+ } Button;
+ 
+ typedef struct {
++	char *token;
++	char *uri;
++} SearchEngine;
++
++typedef struct {
+ 	const char *uri;
+ 	Parameter config[ParameterLast];
+ 	regex_t re;
+@@ -202,6 +207,7 @@ static void responsereceived(WebKitDownload *d, GParamSpec *ps, Client *c);
+ static void download(Client *c, WebKitURIResponse *r);
+ static void closeview(WebKitWebView *v, Client *c);
+ static void destroywin(GtkWidget* w, Client *c);
++static gchar *parseuri(const gchar *uri);
+ 
+ /* Hotkeys */
+ static void pasteuri(GtkClipboard *clipboard, const char *text, gpointer d);
+@@ -477,7 +483,7 @@ loaduri(Client *c, const Arg *a)
+ 		url = g_strdup_printf("file://%s", path);
+ 		free(path);
+ 	} else {
+-		url = g_strdup_printf("http://%s", uri);
++		url = parseuri(uri);
+ 	}
+ 
+ 	setatom(c, AtomUri, url);
+@@ -1461,6 +1467,22 @@ destroywin(GtkWidget* w, Client *c)
+ 		gtk_main_quit();
+ }
+ 
++gchar *
++parseuri(const gchar *uri) {
++	guint i;
++
++	for (i = 0; i < LENGTH(searchengines); i++) {
++		if (searchengines[i].token == NULL || searchengines[i].uri == NULL ||
++		    *(uri + strlen(searchengines[i].token)) != ' ')
++			continue;
++		if (g_str_has_prefix(uri, searchengines[i].token))
++			return g_strdup_printf(searchengines[i].uri,
++					       uri + strlen(searchengines[i].token) + 1);
++	}
++
++	return g_strdup_printf("http://%s", uri);
++}
++
+ void
+ pasteuri(GtkClipboard *clipboard, const char *text, gpointer d)
+ {
diff --git a/suckless/surf/surf-modal-20190209-d068a38.diff b/suckless/surf/surf-modal-20190209-d068a38.diff
@@ -0,0 +1,134 @@
+From 74a98d9600c50d50b9323cf8e459c88eb15da557 Mon Sep 17 00:00:00 2001
+From: efe <efe@efe.kim>
+Date: Sat, 9 Feb 2019 13:16:51 -0500
+Subject: [PATCH] Modal behaviour, 'i' to insert 'Esc' to get to the normal
+ mode
+
+---
+ config.def.h | 53 +++++++++++++++++++++++++++-------------------------
+ surf.c       | 14 +++++++++++++-
+ 2 files changed, 41 insertions(+), 26 deletions(-)
+
+diff --git a/config.def.h b/config.def.h
+index 34265f6..8b7d5a2 100644
+--- a/config.def.h
++++ b/config.def.h
+@@ -130,41 +130,44 @@ static SiteSpecific certs[] = {
+  */
+ static Key keys[] = {
+ 	/* modifier              keyval          function    arg */
+-	{ MODKEY,                GDK_KEY_g,      spawn,      SETPROP("_SURF_URI", "_SURF_GO", PROMPT_GO) },
+-	{ MODKEY,                GDK_KEY_f,      spawn,      SETPROP("_SURF_FIND", "_SURF_FIND", PROMPT_FIND) },
+-	{ MODKEY,                GDK_KEY_slash,  spawn,      SETPROP("_SURF_FIND", "_SURF_FIND", PROMPT_FIND) },
++	{ 0,                     GDK_KEY_g,      spawn,      SETPROP("_SURF_URI", "_SURF_GO", PROMPT_GO) },
++	{ 0,                     GDK_KEY_f,      spawn,      SETPROP("_SURF_FIND", "_SURF_FIND", PROMPT_FIND) },
++	{ 0,                     GDK_KEY_slash,  spawn,      SETPROP("_SURF_FIND", "_SURF_FIND", PROMPT_FIND) },
+ 
+-	{ 0,                     GDK_KEY_Escape, stop,       { 0 } },
+-	{ MODKEY,                GDK_KEY_c,      stop,       { 0 } },
++	{ 0,                     GDK_KEY_i,      insert,     { .i = 1 } },
++	{ 0,                     GDK_KEY_Escape, insert,     { .i = 0 } },
+ 
+-	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_r,      reload,     { .i = 1 } },
+-	{ MODKEY,                GDK_KEY_r,      reload,     { .i = 0 } },
++	{ 0,                     GDK_KEY_c,      stop,       { 0 } },
+ 
+-	{ MODKEY,                GDK_KEY_l,      navigate,   { .i = +1 } },
+-	{ MODKEY,                GDK_KEY_h,      navigate,   { .i = -1 } },
++	{ MODKEY,                GDK_KEY_r,      reload,     { .i = 1 } },
++	{ 0,                     GDK_KEY_r,      reload,     { .i = 0 } },
++
++	{ 0,                     GDK_KEY_l,      navigate,   { .i = +1 } },
++	{ 0,                     GDK_KEY_h,      navigate,   { .i = -1 } },
+ 
+ 	/* vertical and horizontal scrolling, in viewport percentage */
+-	{ MODKEY,                GDK_KEY_j,      scrollv,    { .i = +10 } },
+-	{ MODKEY,                GDK_KEY_k,      scrollv,    { .i = -10 } },
+-	{ MODKEY,                GDK_KEY_space,  scrollv,    { .i = +50 } },
+-	{ MODKEY,                GDK_KEY_b,      scrollv,    { .i = -50 } },
+-	{ MODKEY,                GDK_KEY_i,      scrollh,    { .i = +10 } },
+-	{ MODKEY,                GDK_KEY_u,      scrollh,    { .i = -10 } },
++	{ 0,                     GDK_KEY_j,      scrollv,    { .i = +10 } },
++	{ 0,                     GDK_KEY_k,      scrollv,    { .i = -10 } },
++	{ 0,                     GDK_KEY_space,  scrollv,    { .i = +50 } },
++	{ 0,                     GDK_KEY_b,      scrollv,    { .i = -50 } },
++	{ 0,                     GDK_KEY_i,      scrollh,    { .i = +10 } },
++	{ 0,                     GDK_KEY_u,      scrollh,    { .i = -10 } },
+ 
+ 
+-	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_j,      zoom,       { .i = -1 } },
+-	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_k,      zoom,       { .i = +1 } },
+-	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_q,      zoom,       { .i = 0  } },
+-	{ MODKEY,                GDK_KEY_minus,  zoom,       { .i = -1 } },
+-	{ MODKEY,                GDK_KEY_plus,   zoom,       { .i = +1 } },
++	{ 0|GDK_SHIFT_MASK,      GDK_KEY_j,      zoom,       { .i = -1 } },
++	{ 0|GDK_SHIFT_MASK,      GDK_KEY_k,      zoom,       { .i = +1 } },
++	{ 0|GDK_SHIFT_MASK,      GDK_KEY_q,      zoom,       { .i = 0  } },
++	{ 0,                     GDK_KEY_minus,  zoom,       { .i = -1 } },
++	{ 0|GDK_SHIFT_MASK,      GDK_KEY_plus,   zoom,       { .i = +1 } },
++	{ 0,                     GDK_KEY_equal,  zoom,       { .i = 0  } },
+ 
+-	{ MODKEY,                GDK_KEY_p,      clipboard,  { .i = 1 } },
+-	{ MODKEY,                GDK_KEY_y,      clipboard,  { .i = 0 } },
++	{ 0,                     GDK_KEY_p,      clipboard,  { .i = 1 } },
++	{ 0,                     GDK_KEY_y,      clipboard,  { .i = 0 } },
+ 
+-	{ MODKEY,                GDK_KEY_n,      find,       { .i = +1 } },
+-	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_n,      find,       { .i = -1 } },
++	{ 0,                     GDK_KEY_n,      find,       { .i = +1 } },
++	{ 0|GDK_SHIFT_MASK,      GDK_KEY_n,      find,       { .i = -1 } },
+ 
+-	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_p,      print,      { 0 } },
++	{ MODKEY,                GDK_KEY_p,      print,      { 0 } },
+ 	{ MODKEY,                GDK_KEY_t,      showcert,   { 0 } },
+ 
+ 	{ MODKEY|GDK_SHIFT_MASK, GDK_KEY_a,      togglecookiepolicy, { 0 } },
+diff --git a/surf.c b/surf.c
+index 2b54e3c..f4cbe68 100644
+--- a/surf.c
++++ b/surf.c
+@@ -175,6 +175,7 @@ static void spawn(Client *c, const Arg *a);
+ static void msgext(Client *c, char type, const Arg *a);
+ static void destroyclient(Client *c);
+ static void cleanup(void);
++static int insertmode = 0;
+ 
+ /* GTK/WebKit */
+ static WebKitWebView *newview(Client *c, WebKitWebView *rv);
+@@ -231,6 +232,7 @@ static void togglefullscreen(Client *c, const Arg *a);
+ static void togglecookiepolicy(Client *c, const Arg *a);
+ static void toggleinspector(Client *c, const Arg *a);
+ static void find(Client *c, const Arg *a);
++static void insert(Client *c, const Arg *a);
+ 
+ /* Buttons */
+ static void clicknavigate(Client *c, const Arg *a, WebKitHitTestResult *h);
+@@ -1333,7 +1335,11 @@ winevent(GtkWidget *w, GdkEvent *e, Client *c)
+ 		updatetitle(c);
+ 		break;
+ 	case GDK_KEY_PRESS:
+-		if (!curconfig[KioskMode].val.i) {
++		if (!curconfig[KioskMode].val.i &&
++		    !insertmode ||
++		    CLEANMASK(e->key.state) == (MODKEY|GDK_SHIFT_MASK) ||
++		    CLEANMASK(e->key.state) == (MODKEY) ||
++		    gdk_keyval_to_lower(e->key.keyval) == (GDK_KEY_Escape)) {
+ 			for (i = 0; i < LENGTH(keys); ++i) {
+ 				if (gdk_keyval_to_lower(e->key.keyval) ==
+ 				    keys[i].keyval &&
+@@ -1947,6 +1953,12 @@ find(Client *c, const Arg *a)
+ 	}
+ }
+ 
++void
++insert(Client *c, const Arg *a)
++{
++		insertmode = (a->i);
++}
++
+ void
+ clicknavigate(Client *c, const Arg *a, WebKitHitTestResult *h)
+ {
+-- 
+2.20.1
+
diff --git a/suckless/surf/surf.c b/suckless/surf/surf.c
@@ -0,0 +1,1789 @@
+/* See LICENSE file for copyright and license details.
+ *
+ * To understand surf, start reading main().
+ */
+#include <sys/file.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <libgen.h>
+#include <limits.h>
+#include <pwd.h>
+#include <regex.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk/gdkx.h>
+#include <glib/gstdio.h>
+#include <gtk/gtk.h>
+#include <gtk/gtkx.h>
+#include <JavaScriptCore/JavaScript.h>
+#include <webkit2/webkit2.h>
+#include <X11/X.h>
+#include <X11/Xatom.h>
+
+#include "arg.h"
+
+#define LENGTH(x)               (sizeof(x) / sizeof(x[0]))
+#define CLEANMASK(mask)         (mask & (MODKEY|GDK_SHIFT_MASK))
+#define SETB(p, s)              [p] = { { .b = s }, }
+#define SETI(p, s)              [p] = { { .i = s }, }
+#define SETV(p, s)              [p] = { { .v = s }, }
+#define SETF(p, s)              [p] = { { .f = s }, }
+#define FSETB(p, s)             [p] = { { .b = s }, 1 }
+#define FSETI(p, s)             [p] = { { .i = s }, 1 }
+#define FSETV(p, s)             [p] = { { .v = s }, 1 }
+#define FSETF(p, s)             [p] = { { .f = s }, 1 }
+#define CSETB(p, s)             [p] = (Parameter){ { .b = s }, 1 }
+#define CSETI(p, s)             [p] = (Parameter){ { .i = s }, 1 }
+#define CSETV(p, s)             [p] = (Parameter){ { .v = s }, 1 }
+#define CSETF(p, s)             [p] = (Parameter){ { .f = s }, 1 }
+
+enum { AtomFind, AtomGo, AtomUri, AtomLast };
+
+enum {
+	OnDoc   = WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT,
+	OnLink  = WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK,
+	OnImg   = WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE,
+	OnMedia = WEBKIT_HIT_TEST_RESULT_CONTEXT_MEDIA,
+	OnEdit  = WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE,
+	OnBar   = WEBKIT_HIT_TEST_RESULT_CONTEXT_SCROLLBAR,
+	OnSel   = WEBKIT_HIT_TEST_RESULT_CONTEXT_SELECTION,
+	OnAny   = OnDoc | OnLink | OnImg | OnMedia | OnEdit | OnBar | OnSel,
+};
+
+typedef enum {
+	AcceleratedCanvas,
+	CaretBrowsing,
+	CookiePolicies,
+	DiskCache,
+	DNSPrefetch,
+	FontSize,
+	FrameFlattening,
+	Geolocation,
+	HideBackground,
+	Inspector,
+	JavaScript,
+	KioskMode,
+	LoadImages,
+	MediaManualPlay,
+	Plugins,
+	PreferredLanguages,
+	RunInFullscreen,
+	ScrollBars,
+	ShowIndicators,
+	SiteQuirks,
+	SpellChecking,
+	SpellLanguages,
+	StrictSSL,
+	Style,
+	ZoomLevel,
+	ParameterLast,
+} ParamName;
+
+typedef union {
+	int b;
+	int i;
+	float f;
+	const void *v;
+} Arg;
+
+typedef struct {
+	Arg val;
+	int force;
+} Parameter;
+
+typedef struct Client {
+	GtkWidget *win;
+	WebKitWebView *view;
+	WebKitWebInspector *inspector;
+	WebKitFindController *finder;
+	WebKitHitTestResult *mousepos;
+	GTlsCertificateFlags tlsflags;
+	Window xid;
+	int progress, fullscreen;
+	const char *title, *overtitle, *targeturi;
+	const char *needle;
+	struct Client *next;
+} Client;
+
+typedef struct {
+	guint mod;
+	guint keyval;
+	void (*func)(Client *c, const Arg *a);
+	const Arg arg;
+} Key;
+
+typedef struct {
+	unsigned int target;
+	unsigned int mask;
+	guint button;
+	void (*func)(Client *c, const Arg *a, WebKitHitTestResult *h);
+	const Arg arg;
+	unsigned int stopevent;
+} Button;
+
+typedef struct {
+	char *token;
+	char *uri;
+} SearchEngine;
+
+typedef struct {
+	const char *uri;
+	Parameter config[ParameterLast];
+	regex_t re;
+} UriParameters;
+
+typedef struct {
+	char *regex;
+	char *style;
+	regex_t re;
+} SiteStyle;
+
+/* Surf */
+static void usage(void);
+static void die(const char *errstr, ...);
+static void setup(void);
+static void sigchld(int unused);
+static void sighup(int unused);
+static char *buildfile(const char *path);
+static char *buildpath(const char *path);
+static const char *getuserhomedir(const char *user);
+static const char *getcurrentuserhomedir(void);
+static Client *newclient(Client *c);
+static void loaduri(Client *c, const Arg *a);
+static const char *geturi(Client *c);
+static void setatom(Client *c, int a, const char *v);
+static const char *getatom(Client *c, int a);
+static void updatetitle(Client *c);
+static void gettogglestats(Client *c);
+static void getpagestats(Client *c);
+static WebKitCookieAcceptPolicy cookiepolicy_get(void);
+static char cookiepolicy_set(const WebKitCookieAcceptPolicy p);
+static void seturiparameters(Client *c, const char *uri);
+static void setparameter(Client *c, int refresh, ParamName p, const Arg *a);
+static const char *getstyle(const char *uri);
+static void setstyle(Client *c, const char *stylefile);
+static void runscript(Client *c);
+static void evalscript(Client *c, const char *jsstr, ...);
+static void updatewinid(Client *c);
+static void handleplumb(Client *c, const char *uri);
+static void newwindow(Client *c, const Arg *a, int noembed);
+static void spawn(Client *c, const Arg *a);
+static void destroyclient(Client *c);
+static void cleanup(void);
+
+/* GTK/WebKit */
+static WebKitWebView *newview(Client *c, WebKitWebView *rv);
+static void initwebextensions(WebKitWebContext *wc, Client *c);
+static GtkWidget *createview(WebKitWebView *v, WebKitNavigationAction *a,
+                             Client *c);
+static gboolean buttonreleased(GtkWidget *w, GdkEvent *e, Client *c);
+static GdkFilterReturn processx(GdkXEvent *xevent, GdkEvent *event,
+                                gpointer d);
+static gboolean winevent(GtkWidget *w, GdkEvent *e, Client *c);
+static void showview(WebKitWebView *v, Client *c);
+static GtkWidget *createwindow(Client *c);
+static void loadchanged(WebKitWebView *v, WebKitLoadEvent e, Client *c);
+static void progresschanged(WebKitWebView *v, GParamSpec *ps, Client *c);
+static void titlechanged(WebKitWebView *view, GParamSpec *ps, Client *c);
+static void mousetargetchanged(WebKitWebView *v, WebKitHitTestResult *h,
+                               guint modifiers, Client *c);
+static gboolean permissionrequested(WebKitWebView *v,
+                                    WebKitPermissionRequest *r, Client *c);
+static gboolean decidepolicy(WebKitWebView *v, WebKitPolicyDecision *d,
+                             WebKitPolicyDecisionType dt, Client *c);
+static void decidenavigation(WebKitPolicyDecision *d, Client *c);
+static void decidenewwindow(WebKitPolicyDecision *d, Client *c);
+static void decideresource(WebKitPolicyDecision *d, Client *c);
+static void downloadstarted(WebKitWebContext *wc, WebKitDownload *d,
+                            Client *c);
+static void responsereceived(WebKitDownload *d, GParamSpec *ps, Client *c);
+static void download(Client *c, WebKitURIResponse *r);
+static void closeview(WebKitWebView *v, Client *c);
+static void destroywin(GtkWidget* w, Client *c);
+static gchar *parseuri(const gchar *uri);
+
+/* Hotkeys */
+static void pasteuri(GtkClipboard *clipboard, const char *text, gpointer d);
+static void reload(Client *c, const Arg *a);
+static void print(Client *c, const Arg *a);
+static void clipboard(Client *c, const Arg *a);
+static void zoom(Client *c, const Arg *a);
+static void scroll(Client *c, const Arg *a);
+static void navigate(Client *c, const Arg *a);
+static void stop(Client *c, const Arg *a);
+static void toggle(Client *c, const Arg *a);
+static void togglefullscreen(Client *c, const Arg *a);
+static void togglecookiepolicy(Client *c, const Arg *a);
+static void toggleinspector(Client *c, const Arg *a);
+static void find(Client *c, const Arg *a);
+
+/* Buttons */
+static void clicknavigate(Client *c, const Arg *a, WebKitHitTestResult *h);
+static void clicknewwindow(Client *c, const Arg *a, WebKitHitTestResult *h);
+static void clickexternplayer(Client *c, const Arg *a, WebKitHitTestResult *h);
+
+static char winid[64];
+static char togglestats[10];
+static char pagestats[2];
+static Atom atoms[AtomLast];
+static Window embed;
+static int showxid;
+static int cookiepolicy;
+static Display *dpy;
+static Client *clients;
+static GdkDevice *gdkkb;
+static char *stylefile;
+static const char *useragent;
+static Parameter *curconfig;
+char *argv0;
+
+/* configuration, allows nested code to access above variables */
+#include "config.h"
+
+void
+usage(void)
+{
+	die("usage: %s [-bBdDfFgGiIkKmMnNpPsSvx] [-a cookiepolicies ] "
+	    "[-c cookiefile] [-e xid] [-r scriptfile] [-t stylefile] "
+	    "[-u useragent] [-z zoomlevel] [uri]\n", basename(argv0));
+}
+
+void
+die(const char *errstr, ...)
+{
+	va_list ap;
+
+	va_start(ap, errstr);
+	vfprintf(stderr, errstr, ap);
+	va_end(ap);
+	exit(1);
+}
+
+void
+setup(void)
+{
+	GdkDisplay *gdpy;
+	int i, j;
+
+	/* clean up any zombies immediately */
+	sigchld(0);
+	if (signal(SIGHUP, sighup) == SIG_ERR)
+		die("Can't install SIGHUP handler");
+
+	if (!(dpy = XOpenDisplay(NULL)))
+		die("Can't open default display");
+
+	/* atoms */
+	atoms[AtomFind] = XInternAtom(dpy, "_SURF_FIND", False);
+	atoms[AtomGo] = XInternAtom(dpy, "_SURF_GO", False);
+	atoms[AtomUri] = XInternAtom(dpy, "_SURF_URI", False);
+
+	gtk_init(NULL, NULL);
+
+	gdpy = gdk_display_get_default();
+
+	curconfig = defconfig;
+
+	/* dirs and files */
+	cookiefile = buildfile(cookiefile);
+	scriptfile = buildfile(scriptfile);
+	cachedir   = buildpath(cachedir);
+
+	gdkkb = gdk_seat_get_keyboard(gdk_display_get_default_seat(gdpy));
+
+	if (!stylefile) {
+		styledir = buildpath(styledir);
+		for (i = 0; i < LENGTH(styles); ++i) {
+			if (regcomp(&(styles[i].re), styles[i].regex,
+			    REG_EXTENDED)) {
+				fprintf(stderr,
+				        "Could not compile regex: %s\n",
+				        styles[i].regex);
+				styles[i].regex = NULL;
+			}
+			styles[i].style = g_strconcat(styledir, "/",
+			                              styles[i].style, NULL);
+		}
+		g_free(styledir);
+	} else {
+		stylefile = buildfile(stylefile);
+	}
+
+	for (i = 0; i < LENGTH(uriparams); ++i) {
+		if (!regcomp(&(uriparams[i].re), uriparams[i].uri,
+		    REG_EXTENDED)) {
+			/* copy default parameters if they are not already set
+			 * or if they are forced */
+			for (j = 0; j < ParameterLast; ++j) {
+				if (!uriparams[i].config[j].force ||
+				    defconfig[j].force)
+					uriparams[i].config[j] = defconfig[j];
+			}
+		} else {
+			fprintf(stderr,
+			        "Could not compile regex: %s\n",
+			        uriparams[i].uri);
+			uriparams[i].uri = NULL;
+		}
+	}
+}
+
+void
+sigchld(int unused)
+{
+	if (signal(SIGCHLD, sigchld) == SIG_ERR)
+		die("Can't install SIGCHLD handler");
+	while (waitpid(-1, NULL, WNOHANG) > 0)
+		;
+}
+
+void
+sighup(int unused)
+{
+	Arg a = { .b = 0 };
+	Client *c;
+
+	for (c = clients; c; c = c->next)
+		reload(c, &a);
+}
+
+char *
+buildfile(const char *path)
+{
+	char *dname, *bname, *bpath, *fpath;
+	FILE *f;
+
+	dname = g_path_get_dirname(path);
+	bname = g_path_get_basename(path);
+
+	bpath = buildpath(dname);
+	g_free(dname);
+
+	fpath = g_build_filename(bpath, bname, NULL);
+	g_free(bpath);
+	g_free(bname);
+
+	if (!(f = fopen(fpath, "a")))
+		die("Could not open file: %s\n", fpath);
+
+	g_chmod(fpath, 0600); /* always */
+	fclose(f);
+
+	return fpath;
+}
+
+static const char*
+getuserhomedir(const char *user)
+{
+	struct passwd *pw = getpwnam(user);
+
+	if (!pw)
+		die("Can't get user %s login information.\n", user);
+
+	return pw->pw_dir;
+}
+
+static const char*
+getcurrentuserhomedir(void)
+{
+	const char *homedir;
+	const char *user;
+	struct passwd *pw;
+
+	homedir = getenv("HOME");
+	if (homedir)
+		return homedir;
+
+	user = getenv("USER");
+	if (user)
+		return getuserhomedir(user);
+
+	pw = getpwuid(getuid());
+	if (!pw)
+		die("Can't get current user home directory\n");
+
+	return pw->pw_dir;
+}
+
+char *
+buildpath(const char *path)
+{
+	char *apath, *name, *p, *fpath;
+	const char *homedir;
+
+	if (path[0] == '~') {
+		if (path[1] == '/' || path[1] == '\0') {
+			p = (char *)&path[1];
+			homedir = getcurrentuserhomedir();
+		} else {
+			if ((p = strchr(path, '/')))
+				name = g_strndup(&path[1], --p - path);
+			else
+				name = g_strdup(&path[1]);
+
+			homedir = getuserhomedir(name);
+			g_free(name);
+		}
+		apath = g_build_filename(homedir, p, NULL);
+	} else {
+		apath = g_strdup(path);
+	}
+
+	/* creating directory */
+	if (g_mkdir_with_parents(apath, 0700) < 0)
+		die("Could not access directory: %s\n", apath);
+
+	fpath = realpath(apath, NULL);
+	g_free(apath);
+
+	return fpath;
+}
+
+Client *
+newclient(Client *rc)
+{
+	Client *c;
+
+	if (!(c = calloc(1, sizeof(Client))))
+		die("Cannot malloc!\n");
+
+	c->next = clients;
+	clients = c;
+
+	c->progress = 100;
+	c->tlsflags = G_TLS_CERTIFICATE_VALIDATE_ALL + 1;
+	c->view = newview(c, rc ? rc->view : NULL);
+
+	return c;
+}
+
+void
+loaduri(Client *c, const Arg *a)
+{
+	struct stat st;
+	char *url, *path;
+	const char *uri = a->v;
+
+	if (g_strcmp0(uri, "") == 0)
+		return;
+
+	if (g_str_has_prefix(uri, "http://")  ||
+	    g_str_has_prefix(uri, "https://") ||
+	    g_str_has_prefix(uri, "file://")  ||
+	    g_str_has_prefix(uri, "about:")) {
+		url = g_strdup(uri);
+	} else if (!stat(uri, &st) && (path = realpath(uri, NULL))) {
+		url = g_strdup_printf("file://%s", path);
+		free(path);
+	} else {
+		url = parseuri(uri);
+	}
+
+	setatom(c, AtomUri, url);
+
+	if (strcmp(url, geturi(c)) == 0) {
+		reload(c, a);
+	} else {
+		webkit_web_view_load_uri(c->view, url);
+		updatetitle(c);
+	}
+
+	g_free(url);
+}
+
+const char *
+geturi(Client *c)
+{
+	const char *uri;
+
+	if (!(uri = webkit_web_view_get_uri(c->view)))
+		uri = "about:blank";
+	return uri;
+}
+
+void
+setatom(Client *c, int a, const char *v)
+{
+	XSync(dpy, False);
+	XChangeProperty(dpy, c->xid,
+	                atoms[a], XA_STRING, 8, PropModeReplace,
+	                (unsigned char *)v, strlen(v) + 1);
+}
+
+const char *
+getatom(Client *c, int a)
+{
+	static char buf[BUFSIZ];
+	Atom adummy;
+	int idummy;
+	unsigned long ldummy;
+	unsigned char *p = NULL;
+
+	XGetWindowProperty(dpy, c->xid, atoms[a], 0L, BUFSIZ, False, XA_STRING,
+	                   &adummy, &idummy, &ldummy, &ldummy, &p);
+	if (p)
+		strncpy(buf, (char *)p, LENGTH(buf) - 1);
+	else
+		buf[0] = '\0';
+	XFree(p);
+
+	return buf;
+}
+
+void
+updatetitle(Client *c)
+{
+	char *title;
+	const char *name = c->overtitle ? c->overtitle :
+	                   c->title ? c->title : "";
+
+	if (curconfig[ShowIndicators].val.b) {
+		gettogglestats(c);
+		getpagestats(c);
+
+		if (c->progress != 100)
+			title = g_strdup_printf("[%i%%] %s:%s | %s",
+			        c->progress, togglestats, pagestats, name);
+		else
+			title = g_strdup_printf("%s:%s | %s",
+			        togglestats, pagestats, name);
+
+		gtk_window_set_title(GTK_WINDOW(c->win), title);
+		g_free(title);
+	} else {
+		gtk_window_set_title(GTK_WINDOW(c->win), name);
+	}
+}
+
+void
+gettogglestats(Client *c)
+{
+	togglestats[0] = cookiepolicy_set(cookiepolicy_get());
+	togglestats[1] = curconfig[CaretBrowsing].val.b ?   'C' : 'c';
+	togglestats[2] = curconfig[Geolocation].val.b ?     'G' : 'g';
+	togglestats[3] = curconfig[DiskCache].val.b ?       'D' : 'd';
+	togglestats[4] = curconfig[LoadImages].val.b ?      'I' : 'i';
+	togglestats[5] = curconfig[JavaScript].val.b ?      'S' : 's';
+	togglestats[6] = curconfig[Plugins].val.b ?         'V' : 'v';
+	togglestats[7] = curconfig[Style].val.b ?           'M' : 'm';
+	togglestats[8] = curconfig[FrameFlattening].val.b ? 'F' : 'f';
+	togglestats[9] = '\0';
+}
+
+void
+getpagestats(Client *c)
+{
+	pagestats[0] = c->tlsflags > G_TLS_CERTIFICATE_VALIDATE_ALL ? '-' :
+	               c->tlsflags > 0 ? 'U' : 'T';
+	pagestats[1] = '\0';
+}
+
+WebKitCookieAcceptPolicy
+cookiepolicy_get(void)
+{
+	switch (((char *)curconfig[CookiePolicies].val.v)[cookiepolicy]) {
+	case 'a':
+		return WEBKIT_COOKIE_POLICY_ACCEPT_NEVER;
+	case '@':
+		return WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY;
+	default: /* fallthrough */
+	case 'A':
+		return WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS;
+	}
+}
+
+char
+cookiepolicy_set(const WebKitCookieAcceptPolicy p)
+{
+	switch (p) {
+	case WEBKIT_COOKIE_POLICY_ACCEPT_NEVER:
+		return 'a';
+	case WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY:
+		return '@';
+	default: /* fallthrough */
+	case WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS:
+		return 'A';
+	}
+}
+
+void
+seturiparameters(Client *c, const char *uri)
+{
+	int i;
+
+	for (i = 0; i < LENGTH(uriparams); ++i) {
+		if (uriparams[i].uri &&
+		    !regexec(&(uriparams[i].re), uri, 0, NULL, 0)) {
+			curconfig = uriparams[i].config;
+			break;
+		}
+	}
+
+	for (i = 0; i < ParameterLast; ++i)
+		setparameter(c, 0, i, &curconfig[i].val);
+}
+
+void
+setparameter(Client *c, int refresh, ParamName p, const Arg *a)
+{
+	GdkRGBA bgcolor = { 0 };
+	WebKitSettings *s = webkit_web_view_get_settings(c->view);
+
+	switch (p) {
+	case AcceleratedCanvas:
+		webkit_settings_set_enable_accelerated_2d_canvas(s, a->b);
+		break;
+	case CaretBrowsing:
+		webkit_settings_set_enable_caret_browsing(s, a->b);
+		refresh = 0;
+		break;
+	case CookiePolicies:
+		webkit_cookie_manager_set_accept_policy(
+		    webkit_web_context_get_cookie_manager(
+		    webkit_web_view_get_context(c->view)),
+		    cookiepolicy_get());
+		refresh = 0;
+		break;
+	case DiskCache:
+		webkit_web_context_set_cache_model(
+		    webkit_web_view_get_context(c->view), a->b ?
+		    WEBKIT_CACHE_MODEL_WEB_BROWSER :
+		    WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER);
+		return; /* do not update */
+	case DNSPrefetch:
+		webkit_settings_set_enable_dns_prefetching(s, a->b);
+		return; /* do not update */
+	case FontSize:
+		webkit_settings_set_default_font_size(s, a->i);
+		return; /* do not update */
+	case FrameFlattening:
+		webkit_settings_set_enable_frame_flattening(s, a->b);
+		break;
+	case Geolocation:
+		refresh = 0;
+		break;
+	case HideBackground:
+		if (a->b)
+			webkit_web_view_set_background_color(c->view, &bgcolor);
+		return; /* do not update */
+	case Inspector:
+		webkit_settings_set_enable_developer_extras(s, a->b);
+		return; /* do not update */
+	case JavaScript:
+		webkit_settings_set_enable_javascript(s, a->b);
+		break;
+	case KioskMode:
+		return; /* do nothing */
+	case LoadImages:
+		webkit_settings_set_auto_load_images(s, a->b);
+		break;
+	case MediaManualPlay:
+		webkit_settings_set_media_playback_requires_user_gesture(s, a->b);
+		break;
+	case Plugins:
+		webkit_settings_set_enable_plugins(s, a->b);
+		break;
+	case PreferredLanguages:
+		return; /* do nothing */
+	case RunInFullscreen:
+		return; /* do nothing */
+	case ScrollBars:
+		/* Disabled until we write some WebKitWebExtension for
+		 * manipulating the DOM directly.
+		enablescrollbars = !enablescrollbars;
+		evalscript(c, "document.documentElement.style.overflow = '%s'",
+		    enablescrollbars ? "auto" : "hidden");
+		*/
+		return; /* do not update */
+	case ShowIndicators:
+		break;
+	case SiteQuirks:
+		webkit_settings_set_enable_site_specific_quirks(s, a->b);
+		break;
+	case SpellChecking:
+		webkit_web_context_set_spell_checking_enabled(
+		    webkit_web_view_get_context(c->view), a->b);
+		return; /* do not update */
+	case SpellLanguages:
+		return; /* do nothing */
+	case StrictSSL:
+		webkit_web_context_set_tls_errors_policy(
+		    webkit_web_view_get_context(c->view), a->b ?
+		    WEBKIT_TLS_ERRORS_POLICY_FAIL :
+		    WEBKIT_TLS_ERRORS_POLICY_IGNORE);
+		return; /* do not update */
+	case Style:
+		if (a->b)
+			setstyle(c, getstyle(geturi(c)));
+		else
+			webkit_user_content_manager_remove_all_style_sheets(
+			    webkit_web_view_get_user_content_manager(c->view));
+		refresh = 0;
+		break;
+	case ZoomLevel:
+		webkit_web_view_set_zoom_level(c->view, a->f);
+		return; /* do not update */
+	default:
+		return; /* do nothing */
+	}
+
+	updatetitle(c);
+	if (refresh)
+		reload(c, a);
+}
+
+const char *
+getstyle(const char *uri)
+{
+	int i;
+
+	if (stylefile)
+		return stylefile;
+
+	for (i = 0; i < LENGTH(styles); ++i) {
+		if (styles[i].regex &&
+		    !regexec(&(styles[i].re), uri, 0, NULL, 0))
+			return styles[i].style;
+	}
+
+	return "";
+}
+
+void
+setstyle(Client *c, const char *stylefile)
+{
+	gchar *style;
+
+	if (!g_file_get_contents(stylefile, &style, NULL, NULL)) {
+		fprintf(stderr, "Could not read style file: %s\n", stylefile);
+		return;
+	}
+
+	webkit_user_content_manager_add_style_sheet(
+	    webkit_web_view_get_user_content_manager(c->view),
+	    webkit_user_style_sheet_new(style,
+	    WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES,
+	    WEBKIT_USER_STYLE_LEVEL_USER,
+	    NULL, NULL));
+
+	g_free(style);
+}
+
+void
+runscript(Client *c)
+{
+	gchar *script;
+	gsize l;
+
+	if (g_file_get_contents(scriptfile, &script, &l, NULL) && l)
+		evalscript(c, script);
+	g_free(script);
+}
+
+void
+evalscript(Client *c, const char *jsstr, ...)
+{
+	va_list ap;
+	gchar *script;
+
+	va_start(ap, jsstr);
+	script = g_strdup_vprintf(jsstr, ap);
+	va_end(ap);
+
+	webkit_web_view_run_javascript(c->view, script, NULL, NULL, NULL);
+	g_free(script);
+}
+
+void
+updatewinid(Client *c)
+{
+	snprintf(winid, LENGTH(winid), "%lu", c->xid);
+}
+
+void
+handleplumb(Client *c, const char *uri)
+{
+	Arg a = (Arg)PLUMB(uri);
+	spawn(c, &a);
+}
+
+void
+newwindow(Client *c, const Arg *a, int noembed)
+{
+	int i = 0;
+	char tmp[64];
+	const char *cmd[26], *uri;
+	const Arg arg = { .v = cmd };
+
+	cmd[i++] = argv0;
+	cmd[i++] = "-a";
+	cmd[i++] = curconfig[CookiePolicies].val.v;
+	cmd[i++] = curconfig[ScrollBars].val.b ? "-B" : "-b";
+	if (cookiefile && g_strcmp0(cookiefile, "")) {
+		cmd[i++] = "-c";
+		cmd[i++] = cookiefile;
+	}
+	cmd[i++] = curconfig[DiskCache].val.b ? "-D" : "-d";
+	if (embed && !noembed) {
+		cmd[i++] = "-e";
+		snprintf(tmp, LENGTH(tmp), "%lu", embed);
+		cmd[i++] = tmp;
+	}
+	cmd[i++] = curconfig[RunInFullscreen].val.b ? "-F" : "-f" ;
+	cmd[i++] = curconfig[Geolocation].val.b ?     "-G" : "-g" ;
+	cmd[i++] = curconfig[LoadImages].val.b ?      "-I" : "-i" ;
+	cmd[i++] = curconfig[KioskMode].val.b ?       "-K" : "-k" ;
+	cmd[i++] = curconfig[Style].val.b ?           "-M" : "-m" ;
+	cmd[i++] = curconfig[Inspector].val.b ?       "-N" : "-n" ;
+	cmd[i++] = curconfig[Plugins].val.b ?         "-P" : "-p" ;
+	if (scriptfile && g_strcmp0(scriptfile, "")) {
+		cmd[i++] = "-r";
+		cmd[i++] = scriptfile;
+	}
+	cmd[i++] = curconfig[JavaScript].val.b ? "-S" : "-s";
+	if (stylefile && g_strcmp0(stylefile, "")) {
+		cmd[i++] = "-t";
+		cmd[i++] = stylefile;
+	}
+	if (fulluseragent && g_strcmp0(fulluseragent, "")) {
+		cmd[i++] = "-u";
+		cmd[i++] = fulluseragent;
+	}
+	if (showxid)
+		cmd[i++] = "-x";
+	/* do not keep zoom level */
+	cmd[i++] = "--";
+	if ((uri = a->v))
+		cmd[i++] = uri;
+	cmd[i] = NULL;
+
+	spawn(c, &arg);
+}
+
+void
+spawn(Client *c, const Arg *a)
+{
+	if (fork() == 0) {
+		if (dpy)
+			close(ConnectionNumber(dpy));
+		setsid();
+		execvp(((char **)a->v)[0], (char **)a->v);
+		fprintf(stderr, "%s: execvp %s", argv0, ((char **)a->v)[0]);
+		perror(" failed");
+		exit(1);
+	}
+}
+
+void
+destroyclient(Client *c)
+{
+	Client *p;
+
+	webkit_web_view_stop_loading(c->view);
+	/* Not needed, has already been called
+	gtk_widget_destroy(c->win);
+	 */
+
+	for (p = clients; p && p->next != c; p = p->next)
+		;
+	if (p)
+		p->next = c->next;
+	else
+		clients = c->next;
+	free(c);
+}
+
+void
+cleanup(void)
+{
+	while (clients)
+		destroyclient(clients);
+	g_free(cookiefile);
+	g_free(scriptfile);
+	g_free(stylefile);
+	g_free(cachedir);
+	XCloseDisplay(dpy);
+}
+
+WebKitWebView *
+newview(Client *c, WebKitWebView *rv)
+{
+	WebKitWebView *v;
+	WebKitSettings *settings;
+	WebKitUserContentManager *contentmanager;
+	WebKitWebContext *context;
+
+	/* Webview */
+	if (rv) {
+		v = WEBKIT_WEB_VIEW(
+		    webkit_web_view_new_with_related_view(rv));
+	} else {
+		settings = webkit_settings_new_with_settings(
+		   "auto-load-images", curconfig[LoadImages].val.b,
+		   "default-font-size", curconfig[FontSize].val.i,
+		   "enable-caret-browsing", curconfig[CaretBrowsing].val.b,
+		   "enable-developer-extras", curconfig[Inspector].val.b,
+		   "enable-dns-prefetching", curconfig[DNSPrefetch].val.b,
+		   "enable-frame-flattening", curconfig[FrameFlattening].val.b,
+		   "enable-html5-database", curconfig[DiskCache].val.b,
+		   "enable-html5-local-storage", curconfig[DiskCache].val.b,
+		   "enable-javascript", curconfig[JavaScript].val.b,
+		   "enable-plugins", curconfig[Plugins].val.b,
+		   "enable-accelerated-2d-canvas", curconfig[AcceleratedCanvas].val.b,
+		   "enable-site-specific-quirks", curconfig[SiteQuirks].val.b,
+		   "media-playback-requires-user-gesture", curconfig[MediaManualPlay].val.b,
+		   NULL);
+/* For mor interesting settings, have a look at
+ * http://webkitgtk.org/reference/webkit2gtk/stable/WebKitSettings.html */
+
+		if (strcmp(fulluseragent, "")) {
+			webkit_settings_set_user_agent(settings, fulluseragent);
+		} else if (surfuseragent) {
+			webkit_settings_set_user_agent_with_application_details(
+			    settings, "Surf", VERSION);
+		}
+		useragent = webkit_settings_get_user_agent(settings);
+
+		contentmanager = webkit_user_content_manager_new();
+
+		context = webkit_web_context_new_with_website_data_manager(
+		          webkit_website_data_manager_new(
+		          "base-cache-directory", cachedir,
+		          "base-data-directory", cachedir,
+		          NULL));
+
+		/* rendering process model, can be a shared unique one
+		 * or one for each view */
+		webkit_web_context_set_process_model(context,
+		    WEBKIT_PROCESS_MODEL_MULTIPLE_SECONDARY_PROCESSES);
+		/* ssl */
+		webkit_web_context_set_tls_errors_policy(context,
+		    curconfig[StrictSSL].val.b ? WEBKIT_TLS_ERRORS_POLICY_FAIL :
+		    WEBKIT_TLS_ERRORS_POLICY_IGNORE);
+		/* disk cache */
+		webkit_web_context_set_cache_model(context,
+		    curconfig[DiskCache].val.b ? WEBKIT_CACHE_MODEL_WEB_BROWSER :
+		    WEBKIT_CACHE_MODEL_DOCUMENT_VIEWER);
+
+		/* Currently only works with text file to be compatible with curl */
+		webkit_cookie_manager_set_persistent_storage(
+		    webkit_web_context_get_cookie_manager(context), cookiefile,
+		    WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT);
+		/* cookie policy */
+		webkit_cookie_manager_set_accept_policy(
+		    webkit_web_context_get_cookie_manager(context),
+		    cookiepolicy_get());
+		/* languages */
+		webkit_web_context_set_preferred_languages(context,
+		    curconfig[PreferredLanguages].val.v);
+		webkit_web_context_set_spell_checking_languages(context,
+		    curconfig[SpellLanguages].val.v);
+		webkit_web_context_set_spell_checking_enabled(context,
+		    curconfig[SpellChecking].val.b);
+
+		g_signal_connect(G_OBJECT(context), "download-started",
+		                 G_CALLBACK(downloadstarted), c);
+		g_signal_connect(G_OBJECT(context), "initialize-web-extensions",
+		                 G_CALLBACK(initwebextensions), c);
+
+		v = g_object_new(WEBKIT_TYPE_WEB_VIEW,
+		    "settings", settings,
+		    "user-content-manager", contentmanager,
+		    "web-context", context,
+		    NULL);
+	}
+
+	g_signal_connect(G_OBJECT(v), "notify::estimated-load-progress",
+			 G_CALLBACK(progresschanged), c);
+	g_signal_connect(G_OBJECT(v), "notify::title",
+			 G_CALLBACK(titlechanged), c);
+	g_signal_connect(G_OBJECT(v), "button-release-event",
+			 G_CALLBACK(buttonreleased), c);
+	g_signal_connect(G_OBJECT(v), "close",
+			G_CALLBACK(closeview), c);
+	g_signal_connect(G_OBJECT(v), "create",
+			 G_CALLBACK(createview), c);
+	g_signal_connect(G_OBJECT(v), "decide-policy",
+			 G_CALLBACK(decidepolicy), c);
+	g_signal_connect(G_OBJECT(v), "load-changed",
+			 G_CALLBACK(loadchanged), c);
+	g_signal_connect(G_OBJECT(v), "mouse-target-changed",
+			 G_CALLBACK(mousetargetchanged), c);
+	g_signal_connect(G_OBJECT(v), "permission-request",
+			 G_CALLBACK(permissionrequested), c);
+	g_signal_connect(G_OBJECT(v), "ready-to-show",
+			 G_CALLBACK(showview), c);
+
+	return v;
+}
+
+void
+initwebextensions(WebKitWebContext *wc, Client *c)
+{
+	webkit_web_context_set_web_extensions_directory(wc, WEBEXTDIR);
+}
+
+GtkWidget *
+createview(WebKitWebView *v, WebKitNavigationAction *a, Client *c)
+{
+	Client *n;
+
+	switch (webkit_navigation_action_get_navigation_type(a)) {
+	case WEBKIT_NAVIGATION_TYPE_OTHER: /* fallthrough */
+		/*
+		 * popup windows of type “other” are almost always triggered
+		 * by user gesture, so inverse the logic here
+		 */
+/* instead of this, compare destination uri to mouse-over uri for validating window */
+		if (webkit_navigation_action_is_user_gesture(a))
+			return NULL;
+	case WEBKIT_NAVIGATION_TYPE_LINK_CLICKED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_FORM_SUBMITTED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_BACK_FORWARD: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_RELOAD: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_FORM_RESUBMITTED:
+		n = newclient(c);
+		break;
+	default:
+		return NULL;
+	}
+
+	return GTK_WIDGET(n->view);
+}
+
+gboolean
+buttonreleased(GtkWidget *w, GdkEvent *e, Client *c)
+{
+	WebKitHitTestResultContext element;
+	int i;
+
+	element = webkit_hit_test_result_get_context(c->mousepos);
+
+	for (i = 0; i < LENGTH(buttons); ++i) {
+		if (element & buttons[i].target &&
+		    e->button.button == buttons[i].button &&
+		    CLEANMASK(e->button.state) == CLEANMASK(buttons[i].mask) &&
+		    buttons[i].func) {
+			buttons[i].func(c, &buttons[i].arg, c->mousepos);
+			return buttons[i].stopevent;
+		}
+	}
+
+	return FALSE;
+}
+
+GdkFilterReturn
+processx(GdkXEvent *e, GdkEvent *event, gpointer d)
+{
+	Client *c = (Client *)d;
+	XPropertyEvent *ev;
+	Arg a;
+
+	if (((XEvent *)e)->type == PropertyNotify) {
+		ev = &((XEvent *)e)->xproperty;
+		if (ev->state == PropertyNewValue) {
+			if (ev->atom == atoms[AtomFind]) {
+				find(c, NULL);
+
+				return GDK_FILTER_REMOVE;
+			} else if (ev->atom == atoms[AtomGo]) {
+				a.v = getatom(c, AtomGo);
+				loaduri(c, &a);
+
+				return GDK_FILTER_REMOVE;
+			}
+		}
+	}
+	return GDK_FILTER_CONTINUE;
+}
+
+gboolean
+winevent(GtkWidget *w, GdkEvent *e, Client *c)
+{
+	int i;
+
+	switch (e->type) {
+	case GDK_ENTER_NOTIFY:
+		c->overtitle = c->targeturi;
+		updatetitle(c);
+		break;
+	case GDK_KEY_PRESS:
+		if (!curconfig[KioskMode].val.b) {
+			for (i = 0; i < LENGTH(keys); ++i) {
+				if (gdk_keyval_to_lower(e->key.keyval) ==
+				    keys[i].keyval &&
+				    CLEANMASK(e->key.state) == keys[i].mod &&
+				    keys[i].func) {
+					updatewinid(c);
+					keys[i].func(c, &(keys[i].arg));
+					return TRUE;
+				}
+			}
+		}
+	case GDK_LEAVE_NOTIFY:
+		c->overtitle = NULL;
+		updatetitle(c);
+		break;
+	case GDK_WINDOW_STATE:
+		if (e->window_state.changed_mask ==
+		    GDK_WINDOW_STATE_FULLSCREEN)
+			c->fullscreen = e->window_state.new_window_state &
+			                GDK_WINDOW_STATE_FULLSCREEN;
+		break;
+	default:
+		break;
+	}
+
+	return FALSE;
+}
+
+void
+showview(WebKitWebView *v, Client *c)
+{
+	GdkRGBA bgcolor = { 0 };
+	GdkWindow *gwin;
+
+	c->finder = webkit_web_view_get_find_controller(c->view);
+	c->inspector = webkit_web_view_get_inspector(c->view);
+
+	c->win = createwindow(c);
+
+	gtk_container_add(GTK_CONTAINER(c->win), GTK_WIDGET(c->view));
+	gtk_widget_show_all(c->win);
+	gtk_widget_grab_focus(GTK_WIDGET(c->view));
+
+	gwin = gtk_widget_get_window(GTK_WIDGET(c->win));
+	c->xid = gdk_x11_window_get_xid(gwin);
+	updatewinid(c);
+	if (showxid) {
+		gdk_display_sync(gtk_widget_get_display(c->win));
+		puts(winid);
+	}
+
+	if (curconfig[HideBackground].val.b)
+		webkit_web_view_set_background_color(c->view, &bgcolor);
+
+	if (!curconfig[KioskMode].val.b) {
+		gdk_window_set_events(gwin, GDK_ALL_EVENTS_MASK);
+		gdk_window_add_filter(gwin, processx, c);
+	}
+
+	if (curconfig[RunInFullscreen].val.b)
+		togglefullscreen(c, NULL);
+
+	if (curconfig[ZoomLevel].val.f != 1.0)
+		webkit_web_view_set_zoom_level(c->view,
+		                               curconfig[ZoomLevel].val.f);
+
+	setatom(c, AtomFind, "");
+	setatom(c, AtomUri, "about:blank");
+}
+
+GtkWidget *
+createwindow(Client *c)
+{
+	char *wmstr;
+	GtkWidget *w;
+
+	if (embed) {
+		w = gtk_plug_new(embed);
+	} else {
+		w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+
+		wmstr = g_path_get_basename(argv0);
+		gtk_window_set_wmclass(GTK_WINDOW(w), wmstr, "Surf");
+		g_free(wmstr);
+
+		wmstr = g_strdup_printf("%s[%lu]", "Surf",
+		        webkit_web_view_get_page_id(c->view));
+		gtk_window_set_role(GTK_WINDOW(w), wmstr);
+		g_free(wmstr);
+
+		gtk_window_set_default_size(GTK_WINDOW(w), 800, 600);
+	}
+
+	g_signal_connect(G_OBJECT(w), "destroy",
+	                 G_CALLBACK(destroywin), c);
+	g_signal_connect(G_OBJECT(w), "enter-notify-event",
+	                 G_CALLBACK(winevent), c);
+	g_signal_connect(G_OBJECT(w), "key-press-event",
+	                 G_CALLBACK(winevent), c);
+	g_signal_connect(G_OBJECT(w), "leave-notify-event",
+	                 G_CALLBACK(winevent), c);
+	g_signal_connect(G_OBJECT(w), "window-state-event",
+	                 G_CALLBACK(winevent), c);
+
+	return w;
+}
+
+void
+loadchanged(WebKitWebView *v, WebKitLoadEvent e, Client *c)
+{
+	const char *title = geturi(c);
+
+	switch (e) {
+	case WEBKIT_LOAD_STARTED:
+		curconfig = defconfig;
+		setatom(c, AtomUri, title);
+		c->title = title;
+		c->tlsflags = G_TLS_CERTIFICATE_VALIDATE_ALL + 1;
+		seturiparameters(c, geturi(c));
+		break;
+	case WEBKIT_LOAD_REDIRECTED:
+		setatom(c, AtomUri, title);
+		c->title = title;
+		seturiparameters(c, geturi(c));
+		break;
+	case WEBKIT_LOAD_COMMITTED:
+		if (!webkit_web_view_get_tls_info(c->view, NULL,
+		    &(c->tlsflags)))
+			c->tlsflags = G_TLS_CERTIFICATE_VALIDATE_ALL + 1;
+
+		break;
+	case WEBKIT_LOAD_FINISHED:
+		/* Disabled until we write some WebKitWebExtension for
+		 * manipulating the DOM directly.
+		evalscript(c, "document.documentElement.style.overflow = '%s'",
+		    enablescrollbars ? "auto" : "hidden");
+		*/
+		runscript(c);
+		break;
+	}
+	updatetitle(c);
+}
+
+void
+progresschanged(WebKitWebView *v, GParamSpec *ps, Client *c)
+{
+	c->progress = webkit_web_view_get_estimated_load_progress(c->view) *
+	              100;
+	updatetitle(c);
+}
+
+void
+titlechanged(WebKitWebView *view, GParamSpec *ps, Client *c)
+{
+	c->title = webkit_web_view_get_title(c->view);
+	updatetitle(c);
+}
+
+void
+mousetargetchanged(WebKitWebView *v, WebKitHitTestResult *h, guint modifiers,
+    Client *c)
+{
+	WebKitHitTestResultContext hc = webkit_hit_test_result_get_context(h);
+
+	/* Keep the hit test to know where is the pointer on the next click */
+	c->mousepos = h;
+
+	if (hc & OnLink)
+		c->targeturi = webkit_hit_test_result_get_link_uri(h);
+	else if (hc & OnImg)
+		c->targeturi = webkit_hit_test_result_get_image_uri(h);
+	else if (hc & OnMedia)
+		c->targeturi = webkit_hit_test_result_get_media_uri(h);
+	else
+		c->targeturi = NULL;
+
+	c->overtitle = c->targeturi;
+	updatetitle(c);
+}
+
+gboolean
+permissionrequested(WebKitWebView *v, WebKitPermissionRequest *r, Client *c)
+{
+	if (WEBKIT_IS_GEOLOCATION_PERMISSION_REQUEST(r)) {
+		if (curconfig[Geolocation].val.b)
+			webkit_permission_request_allow(r);
+		else
+			webkit_permission_request_deny(r);
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+gboolean
+decidepolicy(WebKitWebView *v, WebKitPolicyDecision *d,
+    WebKitPolicyDecisionType dt, Client *c)
+{
+	switch (dt) {
+	case WEBKIT_POLICY_DECISION_TYPE_NAVIGATION_ACTION:
+		decidenavigation(d, c);
+		break;
+	case WEBKIT_POLICY_DECISION_TYPE_NEW_WINDOW_ACTION:
+		decidenewwindow(d, c);
+		break;
+	case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
+		decideresource(d, c);
+		break;
+	default:
+		webkit_policy_decision_ignore(d);
+		break;
+	}
+	return TRUE;
+}
+
+void
+decidenavigation(WebKitPolicyDecision *d, Client *c)
+{
+	WebKitNavigationAction *a =
+	    webkit_navigation_policy_decision_get_navigation_action(
+	    WEBKIT_NAVIGATION_POLICY_DECISION(d));
+
+	switch (webkit_navigation_action_get_navigation_type(a)) {
+	case WEBKIT_NAVIGATION_TYPE_LINK_CLICKED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_FORM_SUBMITTED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_BACK_FORWARD: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_RELOAD: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_FORM_RESUBMITTED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_OTHER: /* fallthrough */
+	default:
+		/* Do not navigate to links with a "_blank" target (popup) */
+		if (webkit_navigation_policy_decision_get_frame_name(
+		    WEBKIT_NAVIGATION_POLICY_DECISION(d))) {
+			webkit_policy_decision_ignore(d);
+		} else {
+			/* Filter out navigation to different domain ? */
+			/* get action→urirequest, copy and load in new window+view
+			 * on Ctrl+Click ? */
+			webkit_policy_decision_use(d);
+		}
+		break;
+	}
+}
+
+void
+decidenewwindow(WebKitPolicyDecision *d, Client *c)
+{
+	Arg arg;
+	WebKitNavigationAction *a =
+	    webkit_navigation_policy_decision_get_navigation_action(
+	    WEBKIT_NAVIGATION_POLICY_DECISION(d));
+
+
+	switch (webkit_navigation_action_get_navigation_type(a)) {
+	case WEBKIT_NAVIGATION_TYPE_LINK_CLICKED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_FORM_SUBMITTED: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_BACK_FORWARD: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_RELOAD: /* fallthrough */
+	case WEBKIT_NAVIGATION_TYPE_FORM_RESUBMITTED:
+		/* Filter domains here */
+/* If the value of “mouse-button” is not 0, then the navigation was triggered by a mouse event.
+ * test for link clicked but no button ? */
+		arg.v = webkit_uri_request_get_uri(
+		        webkit_navigation_action_get_request(a));
+		newwindow(c, &arg, 0);
+		break;
+	case WEBKIT_NAVIGATION_TYPE_OTHER: /* fallthrough */
+	default:
+		break;
+	}
+
+	webkit_policy_decision_ignore(d);
+}
+
+void
+decideresource(WebKitPolicyDecision *d, Client *c)
+{
+	int i, isascii = 1;
+	WebKitResponsePolicyDecision *r = WEBKIT_RESPONSE_POLICY_DECISION(d);
+	WebKitURIResponse *res =
+	    webkit_response_policy_decision_get_response(r);
+	const gchar *uri = webkit_uri_response_get_uri(res);
+
+	if (g_str_has_suffix(uri, "/favicon.ico")) {
+		webkit_policy_decision_ignore(d);
+		return;
+	}
+
+	if (!g_str_has_prefix(uri, "http://")
+	    && !g_str_has_prefix(uri, "https://")
+	    && !g_str_has_prefix(uri, "about:")
+	    && !g_str_has_prefix(uri, "file://")
+	    && !g_str_has_prefix(uri, "data:")
+	    && !g_str_has_prefix(uri, "blob:")
+	    && strlen(uri) > 0) {
+		for (i = 0; i < strlen(uri); i++) {
+			if (!g_ascii_isprint(uri[i])) {
+				isascii = 0;
+				break;
+			}
+		}
+		if (isascii) {
+			handleplumb(c, uri);
+			webkit_policy_decision_ignore(d);
+			return;
+		}
+	}
+
+	if (webkit_response_policy_decision_is_mime_type_supported(r)) {
+		webkit_policy_decision_use(d);
+	} else {
+		webkit_policy_decision_ignore(d);
+		download(c, res);
+	}
+}
+
+void
+downloadstarted(WebKitWebContext *wc, WebKitDownload *d, Client *c)
+{
+	g_signal_connect(G_OBJECT(d), "notify::response",
+	                 G_CALLBACK(responsereceived), c);
+}
+
+void
+responsereceived(WebKitDownload *d, GParamSpec *ps, Client *c)
+{
+	download(c, webkit_download_get_response(d));
+	webkit_download_cancel(d);
+}
+
+void
+download(Client *c, WebKitURIResponse *r)
+{
+	Arg a = (Arg)DOWNLOAD(webkit_uri_response_get_uri(r), geturi(c));
+	spawn(c, &a);
+}
+
+void
+closeview(WebKitWebView *v, Client *c)
+{
+	gtk_widget_destroy(c->win);
+}
+
+void
+destroywin(GtkWidget* w, Client *c)
+{
+	destroyclient(c);
+	if (!clients)
+		gtk_main_quit();
+}
+
+gchar *
+parseuri(const gchar *uri) {
+	guint i;
+
+	for (i = 0; i < LENGTH(searchengines); i++) {
+		if (searchengines[i].token == NULL || searchengines[i].uri == NULL ||
+		    *(uri + strlen(searchengines[i].token)) != ' ')
+			continue;
+		if (g_str_has_prefix(uri, searchengines[i].token))
+			return g_strdup_printf(searchengines[i].uri,
+					       uri + strlen(searchengines[i].token) + 1);
+	}
+
+	return g_strdup_printf("http://%s", uri);
+}
+
+void
+pasteuri(GtkClipboard *clipboard, const char *text, gpointer d)
+{
+	Arg a = {.v = text };
+	if (text)
+		loaduri((Client *) d, &a);
+}
+
+void
+reload(Client *c, const Arg *a)
+{
+	if (a->b)
+		webkit_web_view_reload_bypass_cache(c->view);
+	else
+		webkit_web_view_reload(c->view);
+}
+
+void
+print(Client *c, const Arg *a)
+{
+	webkit_print_operation_run_dialog(webkit_print_operation_new(c->view),
+	                                  GTK_WINDOW(c->win));
+}
+
+void
+clipboard(Client *c, const Arg *a)
+{
+	if (a->b) { /* load clipboard uri */
+		gtk_clipboard_request_text(gtk_clipboard_get(
+		                           GDK_SELECTION_PRIMARY),
+		                           pasteuri, c);
+	} else { /* copy uri */
+		gtk_clipboard_set_text(gtk_clipboard_get(
+		                       GDK_SELECTION_PRIMARY), c->targeturi
+		                       ? c->targeturi : geturi(c), -1);
+	}
+}
+
+void
+zoom(Client *c, const Arg *a)
+{
+	if (a->i > 0)
+		webkit_web_view_set_zoom_level(c->view,
+		                               curconfig[ZoomLevel].val.f + 0.1);
+	else if (a->i < 0)
+		webkit_web_view_set_zoom_level(c->view,
+		                               curconfig[ZoomLevel].val.f - 0.1);
+	else
+		webkit_web_view_set_zoom_level(c->view, 1.0);
+
+	curconfig[ZoomLevel].val.f = webkit_web_view_get_zoom_level(c->view);
+}
+
+void
+scroll(Client *c, const Arg *a)
+{
+	GdkEvent *ev = gdk_event_new(GDK_KEY_PRESS);
+
+	gdk_event_set_device(ev, gdkkb);
+	ev->key.window = gtk_widget_get_window(GTK_WIDGET(c->win));
+	ev->key.state = GDK_CONTROL_MASK;
+	ev->key.time = GDK_CURRENT_TIME;
+
+	switch (a->i) {
+	case 'd':
+		ev->key.keyval = GDK_KEY_Down;
+		break;
+	case 'D':
+		ev->key.keyval = GDK_KEY_Page_Down;
+		break;
+	case 'l':
+		ev->key.keyval = GDK_KEY_Left;
+		break;
+	case 'r':
+		ev->key.keyval = GDK_KEY_Right;
+		break;
+	case 'U':
+		ev->key.keyval = GDK_KEY_Page_Up;
+		break;
+	case 'u':
+		ev->key.keyval = GDK_KEY_Up;
+		break;
+	}
+
+	gdk_event_put(ev);
+}
+
+void
+navigate(Client *c, const Arg *a)
+{
+	if (a->i < 0)
+		webkit_web_view_go_back(c->view);
+	else if (a->i > 0)
+		webkit_web_view_go_forward(c->view);
+}
+
+void
+stop(Client *c, const Arg *a)
+{
+	webkit_web_view_stop_loading(c->view);
+}
+
+void
+toggle(Client *c, const Arg *a)
+{
+	curconfig[a->i].val.b ^= 1;
+	setparameter(c, 1, (ParamName)a->i, &curconfig[a->i].val);
+}
+
+void
+togglefullscreen(Client *c, const Arg *a)
+{
+	/* toggling value is handled in winevent() */
+	if (c->fullscreen)
+		gtk_window_unfullscreen(GTK_WINDOW(c->win));
+	else
+		gtk_window_fullscreen(GTK_WINDOW(c->win));
+}
+
+void
+togglecookiepolicy(Client *c, const Arg *a)
+{
+	++cookiepolicy;
+	cookiepolicy %= strlen(curconfig[CookiePolicies].val.v);
+
+	setparameter(c, 0, CookiePolicies, NULL);
+}
+
+void
+toggleinspector(Client *c, const Arg *a)
+{
+	if (webkit_web_inspector_is_attached(c->inspector))
+		webkit_web_inspector_close(c->inspector);
+	else if (curconfig[Inspector].val.b)
+		webkit_web_inspector_show(c->inspector);
+}
+
+void
+find(Client *c, const Arg *a)
+{
+	const char *s, *f;
+
+	if (a && a->i) {
+		if (a->i > 0)
+			webkit_find_controller_search_next(c->finder);
+		else
+			webkit_find_controller_search_previous(c->finder);
+	} else {
+		s = getatom(c, AtomFind);
+		f = webkit_find_controller_get_search_text(c->finder);
+
+		if (g_strcmp0(f, s) == 0) /* reset search */
+			webkit_find_controller_search(c->finder, "", findopts,
+			                              G_MAXUINT);
+
+		webkit_find_controller_search(c->finder, s, findopts,
+		                              G_MAXUINT);
+
+		if (strcmp(s, "") == 0)
+			webkit_find_controller_search_finish(c->finder);
+	}
+}
+
+void
+clicknavigate(Client *c, const Arg *a, WebKitHitTestResult *h)
+{
+	navigate(c, a);
+}
+
+void
+clicknewwindow(Client *c, const Arg *a, WebKitHitTestResult *h)
+{
+	Arg arg;
+
+	arg.v = webkit_hit_test_result_get_link_uri(h);
+	newwindow(c, &arg, a->b);
+}
+
+void
+clickexternplayer(Client *c, const Arg *a, WebKitHitTestResult *h)
+{
+	Arg arg;
+
+	arg = (Arg)VIDEOPLAY(webkit_hit_test_result_get_media_uri(h));
+	spawn(c, &arg);
+}
+
+int
+main(int argc, char *argv[])
+{
+	Arg arg;
+	Client *c;
+
+	memset(&arg, 0, sizeof(arg));
+
+	/* command line args */
+	ARGBEGIN {
+	case 'a':
+		defconfig CSETV(CookiePolicies, EARGF(usage()));
+		break;
+	case 'b':
+		defconfig CSETB(ScrollBars, 0);
+		break;
+	case 'B':
+		defconfig CSETB(ScrollBars, 1);
+		break;
+	case 'c':
+		cookiefile = EARGF(usage());
+		break;
+	case 'd':
+		defconfig CSETB(DiskCache, 0);
+		break;
+	case 'D':
+		defconfig CSETB(DiskCache, 1);
+		break;
+	case 'e':
+		embed = strtol(EARGF(usage()), NULL, 0);
+		break;
+	case 'f':
+		defconfig CSETB(RunInFullscreen, 0);
+		break;
+	case 'F':
+		defconfig CSETB(RunInFullscreen, 1);
+		break;
+	case 'g':
+		defconfig CSETB(Geolocation, 0);
+		break;
+	case 'G':
+		defconfig CSETB(Geolocation, 1);
+		break;
+	case 'i':
+		defconfig CSETB(LoadImages, 0);
+		break;
+	case 'I':
+		defconfig CSETB(LoadImages, 1);
+		break;
+	case 'k':
+		defconfig CSETB(KioskMode, 0);
+		break;
+	case 'K':
+		defconfig CSETB(KioskMode, 1);
+		break;
+	case 'm':
+		defconfig CSETB(Style, 0);
+		break;
+	case 'M':
+		defconfig CSETB(Style, 1);
+		break;
+	case 'n':
+		defconfig CSETB(Inspector, 0);
+		break;
+	case 'N':
+		defconfig CSETB(Inspector, 1);
+		break;
+	case 'p':
+		defconfig CSETB(Plugins, 0);
+		break;
+	case 'P':
+		defconfig CSETB(Plugins, 1);
+		break;
+	case 'r':
+		scriptfile = EARGF(usage());
+		break;
+	case 's':
+		defconfig CSETB(JavaScript, 0);
+		break;
+	case 'S':
+		defconfig CSETB(JavaScript, 1);
+		break;
+	case 't':
+		stylefile = EARGF(usage());
+		break;
+	case 'u':
+		fulluseragent = EARGF(usage());
+		break;
+	case 'v':
+		die("surf-"VERSION", ©2009-2015 surf engineers, "
+		    "see LICENSE for details\n");
+	case 'x':
+		showxid = 1;
+		break;
+	case 'z':
+		defconfig CSETF(ZoomLevel, strtof(EARGF(usage()), NULL));
+		break;
+	default:
+		usage();
+	} ARGEND;
+	if (argc > 0)
+		arg.v = argv[0];
+	else
+		arg.v = "about:blank";
+
+	setup();
+	c = newclient(NULL);
+	showview(NULL, c);
+
+	loaduri(c, &arg);
+	updatetitle(c);
+
+	gtk_main();
+	cleanup();
+
+	return 0;
+}

	dotfiles Unnamed repository; edit this file 'description' to name the repository.
	Log \| Files \| Refs \| README

A	suckless/dmenu/config.def.h	\|	26	++++++++++++++++++++++++++
A	suckless/dmenu/dmenu-border-4.9.diff	\|	25	+++++++++++++++++++++++++
A	suckless/dmenu/dmenu-center-4.8.diff	\|	56	++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	suckless/dwm/dwm-pertag-20170513-ceac8c9.diff	\|	177	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	suckless/dwm/dwm.c	\|	2225	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	suckless/surf/config.def.h	\|	169	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	suckless/surf/surf-git-20170323-webkit2-searchengines.diff	\|	56	++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	suckless/surf/surf-modal-20190209-d068a38.diff	\|	134	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A	suckless/surf/surf.c	\|	1789	+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++