git.stevedylan.dev

several changes, made togglemax extern and separated it from zoom() - moved zoom() and togglemax() into layout.c, changed void (*func)(Arg *) into void (*func)(Arg), changed default keybindings of focusnext/focusprev and incmasterw to h/j/k/l accordingly, made keys in config*h appear alphabetically (special keys first), renamed resizemaster into incmasterw, renamed MASTER into MASTERWIDTH 352cae43

Anselm R. Garbe · 2007-02-22 07:59 10 file(s) · +184 −183

client.c +2 −42

			PropModeReplace, (unsigned char *)data, 2);
}

static void
togglemax(Client *c) {
	XEvent ev;

	if(c->isfixed)
		return;
	if((c->ismax = !c->ismax)) {
		c->rx = c->x;
		c->ry = c->y;
		c->rw = c->w;
		c->rh = c->h;
		resize(c, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
	}
	else
		resize(c, c->rx, c->ry, c->rw, c->rh, True);
	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
}

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

}

void
killclient(Arg *arg) {
killclient(Arg arg) {
	if(!sel)
		return;
	if(isprotodel(sel))

}

void
toggleversatile(Arg *arg) {
toggleversatile(Arg arg) {
	if(!sel || lt->arrange == versatile)
		return;
	sel->isversatile = !sel->isversatile;

	XUngrabServer(dpy);
	lt->arrange();
}

void
zoom(Arg *arg) {
	unsigned int n;
	Client *c;

	if(!sel)
		return;
	if(sel->isversatile || (lt->arrange == versatile)) {
		togglemax(sel);
		return;
	}
	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
		n++;
	if((c = sel) == nexttiled(clients))
		if(!(c = nexttiled(c->next)))
			return;
	detach(c);
	attach(c);
	focus(c);
	lt->arrange();
}

config.arg.h +34 −33

#define TOPBAR			True		/* False */

/* behavior */
#define SNAP			40		/* pixel */
#define TAGS \
const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL };
#define RULES \

	{ "[]=",		tile }, /* first entry is default */ \
	{ "><>",		versatile }, \
};
#define MASTER			600		/* per thousand */
#define MASTERWIDTH		600		/* master width per thousand */
#define NMASTER			1		/* clients in master area */
#define SNAP			40		/* versatile snap pixel */

/* key definitions */
#define MODKEY			Mod1Mask
#define KEYS \
static Key key[] = { \
	/* modifier			key		function	argument */ \
	{ MODKEY|ShiftMask,		XK_Return,	spawn, \
		{ .cmd = "exec urxvtcd -tr -bg '#292929' -fg '#eee' -cr '#eee' +sb -fn '"FONT"'" } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_space,	setlayout,	{ .i = -1 } }, \
	{ MODKEY,			XK_0,		view,		{ .i = -1 } }, \
	{ MODKEY,			XK_1,		view,		{ .i = 0 } }, \
	{ MODKEY,			XK_2,		view,		{ .i = 1 } }, \
	{ MODKEY,			XK_3,		view,		{ .i = 2 } }, \
	{ MODKEY,			XK_4,		view,		{ .i = 3 } }, \
	{ MODKEY,			XK_5,		view,		{ .i = 4 } }, \
	{ MODKEY,			XK_6,		view,		{ .i = 5 } }, \
	{ MODKEY,			XK_7,		view,		{ .i = 6 } }, \
	{ MODKEY,			XK_8,		view,		{ .i = 7 } }, \
	{ MODKEY,			XK_9,		view,		{ .i = 8 } }, \
	{ MODKEY,			XK_d,		incnmaster,	{ .i = -1 } }, \
	{ MODKEY,			XK_h,		incmasterw,	{ .i = -15 } }, \
	{ MODKEY,			XK_i,		incnmaster,	{ .i = 1 } }, \
	{ MODKEY,			XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,			XK_k,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_l,		incmasterw,	{ .i = 15 } }, \
	{ MODKEY,			XK_m,		togglemax,	{ 0 } }, \
	{ MODKEY,			XK_p,		spawn, \
		{ .cmd = "exe=\"$(lsx `echo $PATH | sed 's/:/ /g'` | sort -u " \
			" | dmenu -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' " \
			"-sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"')\" && exec $exe" } }, \
	{ MODKEY,			XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,			XK_k,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_g,		resizemaster,	{ .i = 15 } }, \
	{ MODKEY,			XK_s,		resizemaster,	{ .i = -15 } }, \
	{ MODKEY,			XK_i,		incnmaster,	{ .i = 1 } }, \
	{ MODKEY,			XK_d,		incnmaster,	{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_Return,	spawn, \
		{ .cmd = "exec urxvtcd -tr -bg '#292929' -fg '#eee' -cr '#eee' +sb -fn '"FONT"'" } }, \
	{ MODKEY|ShiftMask,		XK_space,	toggleversatile,{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_0,		tag,		{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \
	{ MODKEY|ShiftMask,		XK_2,		tag,		{ .i = 1 } }, \

	{ MODKEY|ShiftMask,		XK_7,		tag,		{ .i = 6 } }, \
	{ MODKEY|ShiftMask,		XK_8,		tag,		{ .i = 7 } }, \
	{ MODKEY|ShiftMask,		XK_9,		tag,		{ .i = 8 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_1,		toggletag,	{ .i = 0 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_2,		toggletag,	{ .i = 1 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_3,		toggletag,	{ .i = 2 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_4,		toggletag,	{ .i = 3 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_5,		toggletag,	{ .i = 4 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_6,		toggletag,	{ .i = 5 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_7,		toggletag,	{ .i = 6 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_8,		toggletag,	{ .i = 7 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_9,		toggletag,	{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_c,		killclient,	{ 0 } }, \
	{ MODKEY,			XK_space,	setlayout,	{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_space,	toggleversatile,{ 0 } }, \
	{ MODKEY,			XK_0,		view,		{ .i = -1 } }, \
	{ MODKEY,			XK_1,		view,		{ .i = 0 } }, \
	{ MODKEY,			XK_2,		view,		{ .i = 1 } }, \
	{ MODKEY,			XK_3,		view,		{ .i = 2 } }, \
	{ MODKEY,			XK_4,		view,		{ .i = 3 } }, \
	{ MODKEY,			XK_5,		view,		{ .i = 4 } }, \
	{ MODKEY,			XK_6,		view,		{ .i = 5 } }, \
	{ MODKEY,			XK_7,		view,		{ .i = 6 } }, \
	{ MODKEY,			XK_8,		view,		{ .i = 7 } }, \
	{ MODKEY,			XK_9,		view,		{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_q,		quit,		{ 0 } }, \
	{ MODKEY|ControlMask,		XK_1,		toggleview,	{ .i = 0 } }, \
	{ MODKEY|ControlMask,		XK_2,		toggleview,	{ .i = 1 } }, \
	{ MODKEY|ControlMask,		XK_3,		toggleview,	{ .i = 2 } }, \

	{ MODKEY|ControlMask,		XK_7,		toggleview,	{ .i = 6 } }, \
	{ MODKEY|ControlMask,		XK_8,		toggleview,	{ .i = 7 } }, \
	{ MODKEY|ControlMask,		XK_9,		toggleview,	{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_q,		quit,		{ 0 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_1,		toggletag,	{ .i = 0 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_2,		toggletag,	{ .i = 1 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_3,		toggletag,	{ .i = 2 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_4,		toggletag,	{ .i = 3 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_5,		toggletag,	{ .i = 4 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_6,		toggletag,	{ .i = 5 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_7,		toggletag,	{ .i = 6 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_8,		toggletag,	{ .i = 7 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_9,		toggletag,	{ .i = 8 } }, \
};

config.default.h +31 −30

#define TOPBAR			True		/* False */

/* behavior */
#define SNAP			20		/* pixel */
#define TAGS \
const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL };
/* Query class:instance:title for regex matching info with following command:

	{ "[]=",		tile }, /* first entry is default */ \
	{ "><>",		versatile }, \
};
#define MASTER			600		/* per thousand */
#define MASTERWIDTH		600		/* master width per thousand */
#define NMASTER			1		/* clients in master area */
#define SNAP			20		/* versatile snap pixel */

/* key definitions */
#define MODKEY			Mod1Mask
#define KEYS \
static Key key[] = { \
	/* modifier			key		function	argument */ \
	{ MODKEY|ShiftMask,		XK_Return,	spawn,		{ .cmd = "exec xterm" } }, \
	{ MODKEY,			XK_Tab,		focusnext,	{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_Tab,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY,			XK_g,		resizemaster,	{ .i = 15 } }, \
	{ MODKEY,			XK_s,		resizemaster,	{ .i = -15 } }, \
	{ MODKEY,			XK_space,	setlayout,	{ .i = -1 } }, \
	{ MODKEY,			XK_0,		view,		{ .i = -1 } }, \
	{ MODKEY,			XK_1,		view,		{ .i = 0 } }, \
	{ MODKEY,			XK_2,		view,		{ .i = 1 } }, \
	{ MODKEY,			XK_3,		view,		{ .i = 2 } }, \
	{ MODKEY,			XK_4,		view,		{ .i = 3 } }, \
	{ MODKEY,			XK_5,		view,		{ .i = 4 } }, \
	{ MODKEY,			XK_6,		view,		{ .i = 5 } }, \
	{ MODKEY,			XK_7,		view,		{ .i = 6 } }, \
	{ MODKEY,			XK_8,		view,		{ .i = 7 } }, \
	{ MODKEY,			XK_9,		view,		{ .i = 8 } }, \
	{ MODKEY,			XK_d,		incnmaster,	{ .i = -1 } }, \
	{ MODKEY,			XK_h,		incmasterw,	{ .i = -15 } }, \
	{ MODKEY,			XK_i,		incnmaster,	{ .i = 1 } }, \
	{ MODKEY,			XK_d,		incnmaster,	{ .i = -1 } }, \
	{ MODKEY,			XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,			XK_k,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_l,		incmasterw,	{ .i = 15 } }, \
	{ MODKEY,			XK_m,		togglemax,	{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_Return,	spawn,		{ .cmd = "exec xterm" } }, \
	{ MODKEY|ShiftMask,		XK_space,	toggleversatile,{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_0,		tag,		{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \
	{ MODKEY|ShiftMask,		XK_2,		tag,		{ .i = 1 } }, \

	{ MODKEY|ShiftMask,		XK_7,		tag,		{ .i = 6 } }, \
	{ MODKEY|ShiftMask,		XK_8,		tag,		{ .i = 7 } }, \
	{ MODKEY|ShiftMask,		XK_9,		tag,		{ .i = 8 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_1,		toggletag,	{ .i = 0 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_2,		toggletag,	{ .i = 1 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_3,		toggletag,	{ .i = 2 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_4,		toggletag,	{ .i = 3 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_5,		toggletag,	{ .i = 4 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_6,		toggletag,	{ .i = 5 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_7,		toggletag,	{ .i = 6 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_8,		toggletag,	{ .i = 7 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_9,		toggletag,	{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_c,		killclient,	{ 0 } }, \
	{ MODKEY,			XK_space,	setlayout,	{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_space,	toggleversatile,{ 0 } }, \
	{ MODKEY,			XK_0,		view,		{ .i = -1 } }, \
	{ MODKEY,			XK_1,		view,		{ .i = 0 } }, \
	{ MODKEY,			XK_2,		view,		{ .i = 1 } }, \
	{ MODKEY,			XK_3,		view,		{ .i = 2 } }, \
	{ MODKEY,			XK_4,		view,		{ .i = 3 } }, \
	{ MODKEY,			XK_5,		view,		{ .i = 4 } }, \
	{ MODKEY,			XK_6,		view,		{ .i = 5 } }, \
	{ MODKEY,			XK_7,		view,		{ .i = 6 } }, \
	{ MODKEY,			XK_8,		view,		{ .i = 7 } }, \
	{ MODKEY,			XK_9,		view,		{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_q,		quit,		{ 0 } }, \
	{ MODKEY|ControlMask,		XK_1,		toggleview,	{ .i = 0 } }, \
	{ MODKEY|ControlMask,		XK_2,		toggleview,	{ .i = 1 } }, \
	{ MODKEY|ControlMask,		XK_3,		toggleview,	{ .i = 2 } }, \

	{ MODKEY|ControlMask,		XK_7,		toggleview,	{ .i = 6 } }, \
	{ MODKEY|ControlMask,		XK_8,		toggleview,	{ .i = 7 } }, \
	{ MODKEY|ControlMask,		XK_9,		toggleview,	{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_q,		quit,		{ 0 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_1,		toggletag,	{ .i = 0 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_2,		toggletag,	{ .i = 1 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_3,		toggletag,	{ .i = 2 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_4,		toggletag,	{ .i = 3 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_5,		toggletag,	{ .i = 4 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_6,		toggletag,	{ .i = 5 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_7,		toggletag,	{ .i = 6 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_8,		toggletag,	{ .i = 7 } }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_9,		toggletag,	{ .i = 8 } }, \
};

dwm.1 +9 −6

Start
.BR xterm (1).
.TP
.B Mod1-Tab
.B Mod1-j
Focus next window.
.TP
.B Mod1-Shift-Tab
.B Mod1-k
Focus previous window.
.TP
.B Mod1-Return
Zooms/cycles current window to/from master area (tiling layout), toggles maximization of current window (versatile layout).
Zooms/cycles current window to/from master area (tiling layout only).
.TP
.B Mod1-g
.B Mod1-l
Grow master area (tiling layout only).
.TP
.B Mod1-s
.B Mod1-h
Shrink master area (tiling layout only).
.TP
.B Mod1-i

.TP
.B Mod1-d
Decrease the number of windows in the master area (tiling layout only).
.TP
.B Mod1-m
Toggles maximization of current window (versatile layout only).
.TP
.B Mod1-Shift-[1..n]
Apply

Move current window while dragging (versatile layout only).
.TP
.B Mod1-Button2
Zooms/cycles current window to/from master area (tiling layout), toggles maximization of current window (versatile layout).
Zooms/cycles current window to/from master area (tiling layout only).
.TP
.B Mod1-Button3
Resize current window while dragging (versatile layout only).

dwm.h +15 −15

extern int screen, sx, sy, sw, sh;		/* screen geometry */
extern int wax, way, wah, waw;			/* windowarea geometry */
extern unsigned int bh, blw;			/* bar height, bar layout label width */
extern unsigned int master, nmaster;		/* master percent, number of master clients */
extern unsigned int ntags, numlockmask;		/* number of tags, dynamic lock mask */
extern void (*handler[LASTEvent])(XEvent *);	/* event handler */
extern Atom wmatom[WMLast], netatom[NetLast];

/* client.c */
extern void configure(Client *c);		/* send synthetic configure event */
extern void focus(Client *c);			/* focus c, c may be NULL */
extern void killclient(Arg *arg);		/* kill c nicely */
extern void killclient(Arg arg);		/* kill c nicely */
extern void manage(Window w, XWindowAttributes *wa);	/* manage new client */
extern void resize(Client *c, int x, int y,
		int w, int h, Bool sizehints);	/* resize with given coordinates c*/
extern void toggleversatile(Arg *arg);		/* toggles focused client between versatile/and non-versatile state */
extern void toggleversatile(Arg arg);		/* toggles focused client between versatile/and non-versatile state */
extern void updatesizehints(Client *c);		/* update the size hint variables of c */
extern void updatetitle(Client *c);		/* update the name of c */
extern void unmanage(Client *c);		/* destroy c */
extern void zoom(Arg *arg);			/* zooms the focused client to master area, arg is ignored */

/* draw.c */
extern void drawstatus(void);			/* draw the bar */

extern void grabkeys(void);			/* grab all keys defined in config.h */

/* layout.c */
extern void focusnext(Arg *arg);		/* focuses next visible client, arg is ignored  */
extern void focusprev(Arg *arg);		/* focuses previous visible client, arg is ignored */
extern void incnmaster(Arg *arg);		/* increments nmaster with arg's index value */
extern void focusnext(Arg arg);		/* focuses next visible client, arg is ignored  */
extern void focusprev(Arg arg);		/* focuses previous visible client, arg is ignored */
extern void incmasterw(Arg arg);		/* increments the master width with arg's index value */
extern void incnmaster(Arg arg);		/* increments nmaster with arg's index value */
extern void initlayouts(void);			/* initialize layout array */
extern Client *nexttiled(Client *c);		/* returns tiled successor of c */
extern void resizemaster(Arg *arg);		/* resizes the master percent with arg's index value */
extern void restack(void);			/* restores z layers of all clients */
extern void setlayout(Arg *arg);		/* sets layout, -1 toggles */
extern void setlayout(Arg arg);		/* sets layout, -1 toggles */
extern void togglemax(Arg arg);			/* toggles maximization of versatile client */
extern void versatile(void);			/* arranges all windows versatile */

/* main.c */
extern void quit(Arg *arg);			/* quit dwm nicely */
extern void quit(Arg arg);			/* quit dwm nicely */
extern void sendevent(Window w, Atom a, long value);	/* send synthetic event to w */
extern int xerror(Display *dsply, XErrorEvent *ee);	/* dwm's X error handler */


extern void compileregs(void);			/* initialize regexps of rules defined in config.h */
extern Bool isvisible(Client *c);		/* returns True if client is visible */
extern void settags(Client *c, Client *trans);	/* sets tags of c */
extern void tag(Arg *arg);			/* tags c with arg's index */
extern void toggletag(Arg *arg);		/* toggles c tags with arg's index */
extern void toggleview(Arg *arg);		/* toggles the tag with arg's index (in)visible */
extern void view(Arg *arg);			/* views the tag with arg's index */
extern void tag(Arg arg);			/* tags c with arg's index */
extern void toggletag(Arg arg);		/* toggles c tags with arg's index */
extern void toggleview(Arg arg);		/* toggles the tag with arg's index (in)visible */
extern void view(Arg arg);			/* views the tag with arg's index */
extern void zoom(Arg arg);			/* zooms the focused client to master area, arg is ignored */

/* util.c */
extern void *emallocz(unsigned int size);	/* allocates zero-initialized memory, exits on error */
extern void eprint(const char *errstr, ...);	/* prints errstr and exits with 1 */
extern void spawn(Arg *arg);			/* forks a new subprocess with arg's cmd */
extern void spawn(Arg arg);			/* forks a new subprocess with arg's cmd */


event.c +10 −10

typedef struct {
	unsigned long mod;
	KeySym keysym;
	void (*func)(Arg *arg);
	void (*func)(Arg arg);
	Arg arg;
} Key;


			if(ev->x < x) {
				if(ev->button == Button1) {
					if(ev->state & MODKEY)
						tag(&a);
						tag(a);
					else
						view(&a);
						view(a);
				}
				else if(ev->button == Button3) {
					if(ev->state & MODKEY)
						toggletag(&a);
						toggletag(a);
					else
						toggleview(&a);
						toggleview(a);
				}
				return;
			}

			switch(ev->button) {
			case Button1:
				a.i = -1;
				setlayout(&a);
				setlayout(a);
				break;
			case Button4:
				a.i = 1;
				incnmaster(&a);
				incnmaster(a);
				break;
			case Button5:
				a.i = -1;
				incnmaster(&a);
				incnmaster(a);
				break;
			}
	}

			movemouse(c);
		}
		else if(ev->button == Button2)
			zoom(NULL);
			zoom(a);
		else if(ev->button == Button3
		&& (lt->arrange == versatile || c->isversatile) && !c->isfixed)
		{

		&& CLEANMASK(key[i].mod) == CLEANMASK(ev->state))
		{
			if(key[i].func)
				key[i].func(&key[i].arg);
				key[i].func(key[i].arg);
		}
}


layout.c +64 −28

 */
#include "dwm.h"

unsigned int master = MASTER;
unsigned int nmaster = NMASTER;
unsigned int blw = 0;
Layout *lt = NULL;

/* static */

static unsigned int nlayouts = 0;
static unsigned int masterw = MASTERWIDTH;
static unsigned int nmaster = NMASTER;

static void
tile(void) {

		n++;
	/* window geoms */
	mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
	mw = (n > nmaster) ? (waw * master) / 1000 : waw;
	mw = (n > nmaster) ? (waw * masterw) / 1000 : waw;
	th = (n > nmaster) ? wah / (n - nmaster) : 0;
	tw = waw - mw;


/* extern */

void
focusnext(Arg *arg) {
focusnext(Arg arg) {
	Client *c;
   
	if(!sel)

}

void
focusprev(Arg *arg) {
focusprev(Arg arg) {
	Client *c;

	if(!sel)

}

void
incnmaster(Arg *arg) {
	if((lt->arrange != tile) || (nmaster + arg->i < 1)
	|| (wah / (nmaster + arg->i) <= 2 * BORDERPX))
incmasterw(Arg arg) {
	if(lt->arrange != tile)
		return;
	nmaster += arg->i;
	if(arg.i == 0)
		masterw = MASTERWIDTH;
	else {
		if(waw * (masterw + arg.i) / 1000 >= waw - 2 * BORDERPX
		|| waw * (masterw + arg.i) / 1000 <= 2 * BORDERPX)
			return;
		masterw += arg.i;
	}
	lt->arrange();
}

void
incnmaster(Arg arg) {
	if((lt->arrange != tile) || (nmaster + arg.i < 1)
	|| (wah / (nmaster + arg.i) <= 2 * BORDERPX))
		return;
	nmaster += arg.i;
	if(sel)
		lt->arrange();
	else

}

void
resizemaster(Arg *arg) {
	if(lt->arrange != tile)
		return;
	if(arg->i == 0)
		master = MASTER;
	else {
		if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
		|| waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
			return;
		master += arg->i;
	}
	lt->arrange();
}

void
restack(void) {
	Client *c;
	XEvent ev;

}

void
setlayout(Arg *arg) {
setlayout(Arg arg) {
	unsigned int i;

	if(arg->i == -1) {
	if(arg.i == -1) {
		for(i = 0; i < nlayouts && lt != &layout[i]; i++);
		if(i == nlayouts - 1)
			lt = &layout[0];

			lt = &layout[++i];
	}
	else {
		if(arg->i < 0 || arg->i >= nlayouts)
		if(arg.i < 0 || arg.i >= nlayouts)
			return;
		lt = &layout[arg->i];
		lt = &layout[arg.i];
	}
	if(sel)
		lt->arrange();

}

void
togglemax(Arg arg) {
	XEvent ev;

	if(!sel || !sel->isversatile || sel->isfixed || lt->arrange != versatile)
		return;
	if((sel->ismax = !sel->ismax)) {
		sel->rx = sel->x;
		sel->ry = sel->y;
		sel->rw = sel->w;
		sel->rh = sel->h;
		resize(sel, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
	}
	else
		resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);
	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
}

void
versatile(void) {
	Client *c;


	}
	restack();
}

void
zoom(Arg arg) {
	unsigned int n;
	Client *c;

	if(!sel || lt->arrange != tile || sel->isversatile)
		return;
	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
		n++;
	if((c = sel) == nexttiled(clients))
		if(!(c = nexttiled(c->next)))
			return;
	detach(c);
	attach(c);
	focus(c);
	lt->arrange();
}

main.c +1 −1

}

void
quit(Arg *arg) {
quit(Arg arg) {
	readin = running = False;
}


tag.c +14 −14

}

void
tag(Arg *arg) {
tag(Arg arg) {
	unsigned int i;

	if(!sel)
		return;
	for(i = 0; i < ntags; i++)
		sel->tags[i] = (arg->i == -1) ? True : False;
	if(arg->i >= 0 && arg->i < ntags)
		sel->tags[arg->i] = True;
		sel->tags[i] = (arg.i == -1) ? True : False;
	if(arg.i >= 0 && arg.i < ntags)
		sel->tags[arg.i] = True;
	lt->arrange();
}

void
toggletag(Arg *arg) {
toggletag(Arg arg) {
	unsigned int i;

	if(!sel)
		return;
	sel->tags[arg->i] = !sel->tags[arg->i];
	sel->tags[arg.i] = !sel->tags[arg.i];
	for(i = 0; i < ntags && !sel->tags[i]; i++);
	if(i == ntags)
		sel->tags[arg->i] = True;
		sel->tags[arg.i] = True;
	lt->arrange();
}

void
toggleview(Arg *arg) {
toggleview(Arg arg) {
	unsigned int i;

	seltag[arg->i] = !seltag[arg->i];
	seltag[arg.i] = !seltag[arg.i];
	for(i = 0; i < ntags && !seltag[i]; i++);
	if(i == ntags)
		seltag[arg->i] = True; /* cannot toggle last view */
		seltag[arg.i] = True; /* cannot toggle last view */
	lt->arrange();
}

void
view(Arg *arg) {
view(Arg arg) {
	unsigned int i;

	for(i = 0; i < ntags; i++)
		seltag[i] = (arg->i == -1) ? True : False;
	if(arg->i >= 0 && arg->i < ntags)
		seltag[arg->i] = True;
		seltag[i] = (arg.i == -1) ? True : False;
	if(arg.i >= 0 && arg.i < ntags)
		seltag[arg.i] = True;
	lt->arrange();
}

util.c +4 −4

}

void
spawn(Arg *arg) {
spawn(Arg arg) {
	static char *shell = NULL;

	if(!shell && !(shell = getenv("SHELL")))
		shell = "/bin/sh";
	if(!arg->cmd)
	if(!arg.cmd)
		return;
	/* The double-fork construct avoids zombie processes and keeps the code
	 * clean from stupid signal handlers. */

			if(dpy)
				close(ConnectionNumber(dpy));
			setsid();
			execl(shell, shell, "-c", arg->cmd, (char *)NULL);
			fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg->cmd);
			execl(shell, shell, "-c", arg.cmd, (char *)NULL);
			fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg.cmd);
			perror(" failed");
		}
		exit(0);

83	83		PropModeReplace, (unsigned char *)data, 2);
84	84		}
85	85
86		-	static void
87		-	togglemax(Client *c) {
88		-	XEvent ev;
89		-
90		-	if(c->isfixed)
91		-	return;
92		-	if((c->ismax = !c->ismax)) {
93		-	c->rx = c->x;
94		-	c->ry = c->y;
95		-	c->rw = c->w;
96		-	c->rh = c->h;
97		-	resize(c, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
98		-	}
99		-	else
100		-	resize(c, c->rx, c->ry, c->rw, c->rh, True);
101		-	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
102		-	}
103		-
104	86		static int
105	87		xerrordummy(Display dsply, XErrorEvent ee) {
106	88		return 0;

171	153		}
172	154
173	155		void
174		-	killclient(Arg *arg) {
	156	+	killclient(Arg arg) {
175	157		if(!sel)
176	158		return;
177	159		if(isprotodel(sel))

303	285		}
304	286
305	287		void
306		-	toggleversatile(Arg *arg) {
	288	+	toggleversatile(Arg arg) {
307	289		if(!sel \|\| lt->arrange == versatile)
308	290		return;
309	291		sel->isversatile = !sel->isversatile;

402	384		XUngrabServer(dpy);
403	385		lt->arrange();
404	386		}
405		-
406		-	void
407		-	zoom(Arg *arg) {
408		-	unsigned int n;
409		-	Client *c;
410		-
411		-	if(!sel)
412		-	return;
413		-	if(sel->isversatile \|\| (lt->arrange == versatile)) {
414		-	togglemax(sel);
415		-	return;
416		-	}
417		-	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
418		-	n++;
419		-	if((c = sel) == nexttiled(clients))
420		-	if(!(c = nexttiled(c->next)))
421		-	return;
422		-	detach(c);
423		-	attach(c);
424		-	focus(c);
425		-	lt->arrange();
426		-	}

60	60		Start
61	61		.BR xterm (1).
62	62		.TP
63		-	.B Mod1-Tab
	63	+	.B Mod1-j
64	64		Focus next window.
65	65		.TP
66		-	.B Mod1-Shift-Tab
	66	+	.B Mod1-k
67	67		Focus previous window.
68	68		.TP
69	69		.B Mod1-Return
70		-	Zooms/cycles current window to/from master area (tiling layout), toggles maximization of current window (versatile layout).
	70	+	Zooms/cycles current window to/from master area (tiling layout only).
71	71		.TP
72		-	.B Mod1-g
	72	+	.B Mod1-l
73	73		Grow master area (tiling layout only).
74	74		.TP
75		-	.B Mod1-s
	75	+	.B Mod1-h
76	76		Shrink master area (tiling layout only).
77	77		.TP
78	78		.B Mod1-i

80	80		.TP
81	81		.B Mod1-d
82	82		Decrease the number of windows in the master area (tiling layout only).
	83	+	.TP
	84	+	.B Mod1-m
	85	+	Toggles maximization of current window (versatile layout only).
83	86		.TP
84	87		.B Mod1-Shift-[1..n]
85	88		Apply

124	127		Move current window while dragging (versatile layout only).
125	128		.TP
126	129		.B Mod1-Button2
127		-	Zooms/cycles current window to/from master area (tiling layout), toggles maximization of current window (versatile layout).
	130	+	Zooms/cycles current window to/from master area (tiling layout only).
128	131		.TP
129	132		.B Mod1-Button3
130	133		Resize current window while dragging (versatile layout only).

90	90		extern int screen, sx, sy, sw, sh; /* screen geometry */
91	91		extern int wax, way, wah, waw; /* windowarea geometry */
92	92		extern unsigned int bh, blw; /* bar height, bar layout label width */
93		-	extern unsigned int master, nmaster; /* master percent, number of master clients */
94	93		extern unsigned int ntags, numlockmask; /* number of tags, dynamic lock mask */
95	94		extern void (handler[LASTEvent])(XEvent ); /* event handler */
96	95		extern Atom wmatom[WMLast], netatom[NetLast];

105	104		/* client.c */
106	105		extern void configure(Client c); / send synthetic configure event */
107	106		extern void focus(Client c); / focus c, c may be NULL */
108		-	extern void killclient(Arg arg); / kill c nicely */
	107	+	extern void killclient(Arg arg); /* kill c nicely */
109	108		extern void manage(Window w, XWindowAttributes wa); / manage new client */
110	109		extern void resize(Client *c, int x, int y,
111	110		int w, int h, Bool sizehints); /* resize with given coordinates c*/
112		-	extern void toggleversatile(Arg arg); / toggles focused client between versatile/and non-versatile state */
	111	+	extern void toggleversatile(Arg arg); /* toggles focused client between versatile/and non-versatile state */
113	112		extern void updatesizehints(Client c); / update the size hint variables of c */
114	113		extern void updatetitle(Client c); / update the name of c */
115	114		extern void unmanage(Client c); / destroy c */
116		-	extern void zoom(Arg arg); / zooms the focused client to master area, arg is ignored */
117	115
118	116		/* draw.c */
119	117		extern void drawstatus(void); /* draw the bar */

125	123		extern void grabkeys(void); /* grab all keys defined in config.h */
126	124
127	125		/* layout.c */
128		-	extern void focusnext(Arg arg); / focuses next visible client, arg is ignored */
129		-	extern void focusprev(Arg arg); / focuses previous visible client, arg is ignored */
130		-	extern void incnmaster(Arg arg); / increments nmaster with arg's index value */
	126	+	extern void focusnext(Arg arg); /* focuses next visible client, arg is ignored */
	127	+	extern void focusprev(Arg arg); /* focuses previous visible client, arg is ignored */
	128	+	extern void incmasterw(Arg arg); /* increments the master width with arg's index value */
	129	+	extern void incnmaster(Arg arg); /* increments nmaster with arg's index value */
131	130		extern void initlayouts(void); /* initialize layout array */
132	131		extern Client nexttiled(Client c); /* returns tiled successor of c */
133		-	extern void resizemaster(Arg arg); / resizes the master percent with arg's index value */
134	132		extern void restack(void); /* restores z layers of all clients */
135		-	extern void setlayout(Arg arg); / sets layout, -1 toggles */
	133	+	extern void setlayout(Arg arg); /* sets layout, -1 toggles */
	134	+	extern void togglemax(Arg arg); /* toggles maximization of versatile client */
136	135		extern void versatile(void); /* arranges all windows versatile */
137	136
138	137		/* main.c */
139		-	extern void quit(Arg arg); / quit dwm nicely */
	138	+	extern void quit(Arg arg); /* quit dwm nicely */
140	139		extern void sendevent(Window w, Atom a, long value); /* send synthetic event to w */
141	140		extern int xerror(Display dsply, XErrorEvent ee); /* dwm's X error handler */
142	141

144	143		extern void compileregs(void); /* initialize regexps of rules defined in config.h */
145	144		extern Bool isvisible(Client c); / returns True if client is visible */
146	145		extern void settags(Client c, Client trans); /* sets tags of c */
147		-	extern void tag(Arg arg); / tags c with arg's index */
148		-	extern void toggletag(Arg arg); / toggles c tags with arg's index */
149		-	extern void toggleview(Arg arg); / toggles the tag with arg's index (in)visible */
150		-	extern void view(Arg arg); / views the tag with arg's index */
	146	+	extern void tag(Arg arg); /* tags c with arg's index */
	147	+	extern void toggletag(Arg arg); /* toggles c tags with arg's index */
	148	+	extern void toggleview(Arg arg); /* toggles the tag with arg's index (in)visible */
	149	+	extern void view(Arg arg); /* views the tag with arg's index */
	150	+	extern void zoom(Arg arg); /* zooms the focused client to master area, arg is ignored */
151	151
152	152		/* util.c */
153	153		extern void emallocz(unsigned int size); / allocates zero-initialized memory, exits on error */
154	154		extern void eprint(const char errstr, ...); / prints errstr and exits with 1 */
155		-	extern void spawn(Arg arg); / forks a new subprocess with arg's cmd */
	155	+	extern void spawn(Arg arg); /* forks a new subprocess with arg's cmd */
156	156

11	11		typedef struct {
12	12		unsigned long mod;
13	13		KeySym keysym;
14		-	void (func)(Arg arg);
	14	+	void (*func)(Arg arg);
15	15		Arg arg;
16	16		} Key;
17	17

124	124		if(ev->x < x) {
125	125		if(ev->button == Button1) {
126	126		if(ev->state & MODKEY)
127		-	tag(&a);
	127	+	tag(a);
128	128		else
129		-	view(&a);
	129	+	view(a);
130	130		}
131	131		else if(ev->button == Button3) {
132	132		if(ev->state & MODKEY)
133		-	toggletag(&a);
	133	+	toggletag(a);
134	134		else
135		-	toggleview(&a);
	135	+	toggleview(a);
136	136		}
137	137		return;
138	138		}

141	141		switch(ev->button) {
142	142		case Button1:
143	143		a.i = -1;
144		-	setlayout(&a);
	144	+	setlayout(a);
145	145		break;
146	146		case Button4:
147	147		a.i = 1;
148		-	incnmaster(&a);
	148	+	incnmaster(a);
149	149		break;
150	150		case Button5:
151	151		a.i = -1;
152		-	incnmaster(&a);
	152	+	incnmaster(a);
153	153		break;
154	154		}
155	155		}

162	162		movemouse(c);
163	163		}
164	164		else if(ev->button == Button2)
165		-	zoom(NULL);
	165	+	zoom(a);
166	166		else if(ev->button == Button3
167	167		&& (lt->arrange == versatile \|\| c->isversatile) && !c->isfixed)
168	168		{

261	261		&& CLEANMASK(key[i].mod) == CLEANMASK(ev->state))
262	262		{
263	263		if(key[i].func)
264		-	key[i].func(&key[i].arg);
	264	+	key[i].func(key[i].arg);
265	265		}
266	266		}
267	267

3	3		*/
4	4		#include "dwm.h"
5	5
6		-	unsigned int master = MASTER;
7		-	unsigned int nmaster = NMASTER;
8	6		unsigned int blw = 0;
9	7		Layout *lt = NULL;
10	8
11	9		/* static */
12	10
13	11		static unsigned int nlayouts = 0;
	12	+	static unsigned int masterw = MASTERWIDTH;
	13	+	static unsigned int nmaster = NMASTER;
14	14
15	15		static void
16	16		tile(void) {

21	21		n++;
22	22		/* window geoms */
23	23		mh = (n > nmaster) ? wah / nmaster : wah / (n > 0 ? n : 1);
24		-	mw = (n > nmaster) ? (waw * master) / 1000 : waw;
	24	+	mw = (n > nmaster) ? (waw * masterw) / 1000 : waw;
25	25		th = (n > nmaster) ? wah / (n - nmaster) : 0;
26	26		tw = waw - mw;
27	27

69	69		/* extern */
70	70
71	71		void
72		-	focusnext(Arg *arg) {
	72	+	focusnext(Arg arg) {
73	73		Client *c;
74	74
75	75		if(!sel)

84	84		}
85	85
86	86		void
87		-	focusprev(Arg *arg) {
	87	+	focusprev(Arg arg) {
88	88		Client *c;
89	89
90	90		if(!sel)

101	101		}
102	102
103	103		void
104		-	incnmaster(Arg *arg) {
105		-	if((lt->arrange != tile) \|\| (nmaster + arg->i < 1)
106		-	\|\| (wah / (nmaster + arg->i) <= 2 * BORDERPX))
	104	+	incmasterw(Arg arg) {
	105	+	if(lt->arrange != tile)
107	106		return;
108		-	nmaster += arg->i;
	107	+	if(arg.i == 0)
	108	+	masterw = MASTERWIDTH;
	109	+	else {
	110	+	if(waw * (masterw + arg.i) / 1000 >= waw - 2 * BORDERPX
	111	+	\|\| waw * (masterw + arg.i) / 1000 <= 2 * BORDERPX)
	112	+	return;
	113	+	masterw += arg.i;
	114	+	}
	115	+	lt->arrange();
	116	+	}
	117	+
	118	+	void
	119	+	incnmaster(Arg arg) {
	120	+	if((lt->arrange != tile) \|\| (nmaster + arg.i < 1)
	121	+	\|\| (wah / (nmaster + arg.i) <= 2 * BORDERPX))
	122	+	return;
	123	+	nmaster += arg.i;
109	124		if(sel)
110	125		lt->arrange();
111	126		else

132	147		}
133	148
134	149		void
135		-	resizemaster(Arg *arg) {
136		-	if(lt->arrange != tile)
137		-	return;
138		-	if(arg->i == 0)
139		-	master = MASTER;
140		-	else {
141		-	if(waw * (master + arg->i) / 1000 >= waw - 2 * BORDERPX
142		-	\|\| waw * (master + arg->i) / 1000 <= 2 * BORDERPX)
143		-	return;
144		-	master += arg->i;
145		-	}
146		-	lt->arrange();
147		-	}
148		-
149		-	void
150	150		restack(void) {
151	151		Client *c;
152	152		XEvent ev;

170	170		}
171	171
172	172		void
173		-	setlayout(Arg *arg) {
	173	+	setlayout(Arg arg) {
174	174		unsigned int i;
175	175
176		-	if(arg->i == -1) {
	176	+	if(arg.i == -1) {
177	177		for(i = 0; i < nlayouts && lt != &layout[i]; i++);
178	178		if(i == nlayouts - 1)
179	179		lt = &layout[0];

181	181		lt = &layout[++i];
182	182		}
183	183		else {
184		-	if(arg->i < 0 \|\| arg->i >= nlayouts)
	184	+	if(arg.i < 0 \|\| arg.i >= nlayouts)
185	185		return;
186		-	lt = &layout[arg->i];
	186	+	lt = &layout[arg.i];
187	187		}
188	188		if(sel)
189	189		lt->arrange();

192	192		}
193	193
194	194		void
	195	+	togglemax(Arg arg) {
	196	+	XEvent ev;
	197	+
	198	+	if(!sel \|\| !sel->isversatile \|\| sel->isfixed \|\| lt->arrange != versatile)
	199	+	return;
	200	+	if((sel->ismax = !sel->ismax)) {
	201	+	sel->rx = sel->x;
	202	+	sel->ry = sel->y;
	203	+	sel->rw = sel->w;
	204	+	sel->rh = sel->h;
	205	+	resize(sel, wax, way, waw - 2 * BORDERPX, wah - 2 * BORDERPX, True);
	206	+	}
	207	+	else
	208	+	resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, True);
	209	+	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
	210	+	}
	211	+
	212	+	void
195	213		versatile(void) {
196	214		Client *c;
197	215

213	231		}
214	232		restack();
215	233		}
	234	+
	235	+	void
	236	+	zoom(Arg arg) {
	237	+	unsigned int n;
	238	+	Client *c;
	239	+
	240	+	if(!sel \|\| lt->arrange != tile \|\| sel->isversatile)
	241	+	return;
	242	+	for(n = 0, c = nexttiled(clients); c; c = nexttiled(c->next))
	243	+	n++;
	244	+	if((c = sel) == nexttiled(clients))
	245	+	if(!(c = nexttiled(c->next)))
	246	+	return;
	247	+	detach(c);
	248	+	attach(c);
	249	+	focus(c);
	250	+	lt->arrange();
	251	+	}

14	14		#define TOPBAR True /* False */
15	15
16	16		/* behavior */
17		-	#define SNAP 40 /* pixel */
18	17		#define TAGS \
19	18		const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL };
20	19		#define RULES \

33	32		{ "[]=", tile }, /* first entry is default */ \
34	33		{ "><>", versatile }, \
35	34		};
36		-	#define MASTER 600 /* per thousand */
	35	+	#define MASTERWIDTH 600 /* master width per thousand */
37	36		#define NMASTER 1 /* clients in master area */
	37	+	#define SNAP 40 /* versatile snap pixel */
38	38
39	39		/* key definitions */
40	40		#define MODKEY Mod1Mask
41	41		#define KEYS \
42	42		static Key key[] = { \
43	43		/* modifier key function argument */ \
44		-	{ MODKEY\|ShiftMask, XK_Return, spawn, \
45		-	{ .cmd = "exec urxvtcd -tr -bg '#292929' -fg '#eee' -cr '#eee' +sb -fn '"FONT"'" } }, \
	44	+	{ MODKEY, XK_Return, zoom, { 0 } }, \
	45	+	{ MODKEY, XK_space, setlayout, { .i = -1 } }, \
	46	+	{ MODKEY, XK_0, view, { .i = -1 } }, \
	47	+	{ MODKEY, XK_1, view, { .i = 0 } }, \
	48	+	{ MODKEY, XK_2, view, { .i = 1 } }, \
	49	+	{ MODKEY, XK_3, view, { .i = 2 } }, \
	50	+	{ MODKEY, XK_4, view, { .i = 3 } }, \
	51	+	{ MODKEY, XK_5, view, { .i = 4 } }, \
	52	+	{ MODKEY, XK_6, view, { .i = 5 } }, \
	53	+	{ MODKEY, XK_7, view, { .i = 6 } }, \
	54	+	{ MODKEY, XK_8, view, { .i = 7 } }, \
	55	+	{ MODKEY, XK_9, view, { .i = 8 } }, \
	56	+	{ MODKEY, XK_d, incnmaster, { .i = -1 } }, \
	57	+	{ MODKEY, XK_h, incmasterw, { .i = -15 } }, \
	58	+	{ MODKEY, XK_i, incnmaster, { .i = 1 } }, \
	59	+	{ MODKEY, XK_j, focusnext, { 0 } }, \
	60	+	{ MODKEY, XK_k, focusprev, { 0 } }, \
	61	+	{ MODKEY, XK_l, incmasterw, { .i = 15 } }, \
	62	+	{ MODKEY, XK_m, togglemax, { 0 } }, \
46	63		{ MODKEY, XK_p, spawn, \
47	64		{ .cmd = "exe=\"$(lsx `echo $PATH \| sed 's/:/ /g'` \| sort -u " \
48	65		" \| dmenu -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' " \
49	66		"-sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"')\" && exec $exe" } }, \
50		-	{ MODKEY, XK_j, focusnext, { 0 } }, \
51		-	{ MODKEY, XK_k, focusprev, { 0 } }, \
52		-	{ MODKEY, XK_Return, zoom, { 0 } }, \
53		-	{ MODKEY, XK_g, resizemaster, { .i = 15 } }, \
54		-	{ MODKEY, XK_s, resizemaster, { .i = -15 } }, \
55		-	{ MODKEY, XK_i, incnmaster, { .i = 1 } }, \
56		-	{ MODKEY, XK_d, incnmaster, { .i = -1 } }, \
	67	+	{ MODKEY\|ShiftMask, XK_Return, spawn, \
	68	+	{ .cmd = "exec urxvtcd -tr -bg '#292929' -fg '#eee' -cr '#eee' +sb -fn '"FONT"'" } }, \
	69	+	{ MODKEY\|ShiftMask, XK_space, toggleversatile,{ 0 } }, \
57	70		{ MODKEY\|ShiftMask, XK_0, tag, { .i = -1 } }, \
58	71		{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \
59	72		{ MODKEY\|ShiftMask, XK_2, tag, { .i = 1 } }, \

64	77		{ MODKEY\|ShiftMask, XK_7, tag, { .i = 6 } }, \
65	78		{ MODKEY\|ShiftMask, XK_8, tag, { .i = 7 } }, \
66	79		{ MODKEY\|ShiftMask, XK_9, tag, { .i = 8 } }, \
67		-	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, { .i = 0 } }, \
68		-	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, { .i = 1 } }, \
69		-	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, { .i = 2 } }, \
70		-	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, { .i = 3 } }, \
71		-	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, { .i = 4 } }, \
72		-	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, { .i = 5 } }, \
73		-	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, { .i = 6 } }, \
74		-	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, { .i = 7 } }, \
75		-	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, { .i = 8 } }, \
76	80		{ MODKEY\|ShiftMask, XK_c, killclient, { 0 } }, \
77		-	{ MODKEY, XK_space, setlayout, { .i = -1 } }, \
78		-	{ MODKEY\|ShiftMask, XK_space, toggleversatile,{ 0 } }, \
79		-	{ MODKEY, XK_0, view, { .i = -1 } }, \
80		-	{ MODKEY, XK_1, view, { .i = 0 } }, \
81		-	{ MODKEY, XK_2, view, { .i = 1 } }, \
82		-	{ MODKEY, XK_3, view, { .i = 2 } }, \
83		-	{ MODKEY, XK_4, view, { .i = 3 } }, \
84		-	{ MODKEY, XK_5, view, { .i = 4 } }, \
85		-	{ MODKEY, XK_6, view, { .i = 5 } }, \
86		-	{ MODKEY, XK_7, view, { .i = 6 } }, \
87		-	{ MODKEY, XK_8, view, { .i = 7 } }, \
88		-	{ MODKEY, XK_9, view, { .i = 8 } }, \
	81	+	{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
89	82		{ MODKEY\|ControlMask, XK_1, toggleview, { .i = 0 } }, \
90	83		{ MODKEY\|ControlMask, XK_2, toggleview, { .i = 1 } }, \
91	84		{ MODKEY\|ControlMask, XK_3, toggleview, { .i = 2 } }, \

95	88		{ MODKEY\|ControlMask, XK_7, toggleview, { .i = 6 } }, \
96	89		{ MODKEY\|ControlMask, XK_8, toggleview, { .i = 7 } }, \
97	90		{ MODKEY\|ControlMask, XK_9, toggleview, { .i = 8 } }, \
98		-	{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
	91	+	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, { .i = 0 } }, \
	92	+	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, { .i = 1 } }, \
	93	+	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, { .i = 2 } }, \
	94	+	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, { .i = 3 } }, \
	95	+	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, { .i = 4 } }, \
	96	+	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, { .i = 5 } }, \
	97	+	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, { .i = 6 } }, \
	98	+	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, { .i = 7 } }, \
	99	+	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, { .i = 8 } }, \
99	100		};

14	14		#define TOPBAR True /* False */
15	15
16	16		/* behavior */
17		-	#define SNAP 20 /* pixel */
18	17		#define TAGS \
19	18		const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL };
20	19		/* Query class:instance:title for regex matching info with following command:

34	33		{ "[]=", tile }, /* first entry is default */ \
35	34		{ "><>", versatile }, \
36	35		};
37		-	#define MASTER 600 /* per thousand */
	36	+	#define MASTERWIDTH 600 /* master width per thousand */
38	37		#define NMASTER 1 /* clients in master area */
	38	+	#define SNAP 20 /* versatile snap pixel */
39	39
40	40		/* key definitions */
41	41		#define MODKEY Mod1Mask
42	42		#define KEYS \
43	43		static Key key[] = { \
44	44		/* modifier key function argument */ \
45		-	{ MODKEY\|ShiftMask, XK_Return, spawn, { .cmd = "exec xterm" } }, \
46		-	{ MODKEY, XK_Tab, focusnext, { 0 } }, \
47		-	{ MODKEY\|ShiftMask, XK_Tab, focusprev, { 0 } }, \
48	45		{ MODKEY, XK_Return, zoom, { 0 } }, \
49		-	{ MODKEY, XK_g, resizemaster, { .i = 15 } }, \
50		-	{ MODKEY, XK_s, resizemaster, { .i = -15 } }, \
	46	+	{ MODKEY, XK_space, setlayout, { .i = -1 } }, \
	47	+	{ MODKEY, XK_0, view, { .i = -1 } }, \
	48	+	{ MODKEY, XK_1, view, { .i = 0 } }, \
	49	+	{ MODKEY, XK_2, view, { .i = 1 } }, \
	50	+	{ MODKEY, XK_3, view, { .i = 2 } }, \
	51	+	{ MODKEY, XK_4, view, { .i = 3 } }, \
	52	+	{ MODKEY, XK_5, view, { .i = 4 } }, \
	53	+	{ MODKEY, XK_6, view, { .i = 5 } }, \
	54	+	{ MODKEY, XK_7, view, { .i = 6 } }, \
	55	+	{ MODKEY, XK_8, view, { .i = 7 } }, \
	56	+	{ MODKEY, XK_9, view, { .i = 8 } }, \
	57	+	{ MODKEY, XK_d, incnmaster, { .i = -1 } }, \
	58	+	{ MODKEY, XK_h, incmasterw, { .i = -15 } }, \
51	59		{ MODKEY, XK_i, incnmaster, { .i = 1 } }, \
52		-	{ MODKEY, XK_d, incnmaster, { .i = -1 } }, \
	60	+	{ MODKEY, XK_j, focusnext, { 0 } }, \
	61	+	{ MODKEY, XK_k, focusprev, { 0 } }, \
	62	+	{ MODKEY, XK_l, incmasterw, { .i = 15 } }, \
	63	+	{ MODKEY, XK_m, togglemax, { 0 } }, \
	64	+	{ MODKEY\|ShiftMask, XK_Return, spawn, { .cmd = "exec xterm" } }, \
	65	+	{ MODKEY\|ShiftMask, XK_space, toggleversatile,{ 0 } }, \
53	66		{ MODKEY\|ShiftMask, XK_0, tag, { .i = -1 } }, \
54	67		{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \
55	68		{ MODKEY\|ShiftMask, XK_2, tag, { .i = 1 } }, \

60	73		{ MODKEY\|ShiftMask, XK_7, tag, { .i = 6 } }, \
61	74		{ MODKEY\|ShiftMask, XK_8, tag, { .i = 7 } }, \
62	75		{ MODKEY\|ShiftMask, XK_9, tag, { .i = 8 } }, \
63		-	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, { .i = 0 } }, \
64		-	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, { .i = 1 } }, \
65		-	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, { .i = 2 } }, \
66		-	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, { .i = 3 } }, \
67		-	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, { .i = 4 } }, \
68		-	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, { .i = 5 } }, \
69		-	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, { .i = 6 } }, \
70		-	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, { .i = 7 } }, \
71		-	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, { .i = 8 } }, \
72	76		{ MODKEY\|ShiftMask, XK_c, killclient, { 0 } }, \
73		-	{ MODKEY, XK_space, setlayout, { .i = -1 } }, \
74		-	{ MODKEY\|ShiftMask, XK_space, toggleversatile,{ 0 } }, \
75		-	{ MODKEY, XK_0, view, { .i = -1 } }, \
76		-	{ MODKEY, XK_1, view, { .i = 0 } }, \
77		-	{ MODKEY, XK_2, view, { .i = 1 } }, \
78		-	{ MODKEY, XK_3, view, { .i = 2 } }, \
79		-	{ MODKEY, XK_4, view, { .i = 3 } }, \
80		-	{ MODKEY, XK_5, view, { .i = 4 } }, \
81		-	{ MODKEY, XK_6, view, { .i = 5 } }, \
82		-	{ MODKEY, XK_7, view, { .i = 6 } }, \
83		-	{ MODKEY, XK_8, view, { .i = 7 } }, \
84		-	{ MODKEY, XK_9, view, { .i = 8 } }, \
	77	+	{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
85	78		{ MODKEY\|ControlMask, XK_1, toggleview, { .i = 0 } }, \
86	79		{ MODKEY\|ControlMask, XK_2, toggleview, { .i = 1 } }, \
87	80		{ MODKEY\|ControlMask, XK_3, toggleview, { .i = 2 } }, \

91	84		{ MODKEY\|ControlMask, XK_7, toggleview, { .i = 6 } }, \
92	85		{ MODKEY\|ControlMask, XK_8, toggleview, { .i = 7 } }, \
93	86		{ MODKEY\|ControlMask, XK_9, toggleview, { .i = 8 } }, \
94		-	{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
	87	+	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, { .i = 0 } }, \
	88	+	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, { .i = 1 } }, \
	89	+	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, { .i = 2 } }, \
	90	+	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, { .i = 3 } }, \
	91	+	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, { .i = 4 } }, \
	92	+	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, { .i = 5 } }, \
	93	+	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, { .i = 6 } }, \
	94	+	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, { .i = 7 } }, \
	95	+	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, { .i = 8 } }, \
95	96		};

236	236		}
237	237
238	238		void
239		-	quit(Arg *arg) {
	239	+	quit(Arg arg) {
240	240		readin = running = False;
241	241		}
242	242

102	102		}
103	103
104	104		void
105		-	tag(Arg *arg) {
	105	+	tag(Arg arg) {
106	106		unsigned int i;
107	107
108	108		if(!sel)
109	109		return;
110	110		for(i = 0; i < ntags; i++)
111		-	sel->tags[i] = (arg->i == -1) ? True : False;
112		-	if(arg->i >= 0 && arg->i < ntags)
113		-	sel->tags[arg->i] = True;
	111	+	sel->tags[i] = (arg.i == -1) ? True : False;
	112	+	if(arg.i >= 0 && arg.i < ntags)
	113	+	sel->tags[arg.i] = True;
114	114		lt->arrange();
115	115		}
116	116
117	117		void
118		-	toggletag(Arg *arg) {
	118	+	toggletag(Arg arg) {
119	119		unsigned int i;
120	120
121	121		if(!sel)
122	122		return;
123		-	sel->tags[arg->i] = !sel->tags[arg->i];
	123	+	sel->tags[arg.i] = !sel->tags[arg.i];
124	124		for(i = 0; i < ntags && !sel->tags[i]; i++);
125	125		if(i == ntags)
126		-	sel->tags[arg->i] = True;
	126	+	sel->tags[arg.i] = True;
127	127		lt->arrange();
128	128		}
129	129
130	130		void
131		-	toggleview(Arg *arg) {
	131	+	toggleview(Arg arg) {
132	132		unsigned int i;
133	133
134		-	seltag[arg->i] = !seltag[arg->i];
	134	+	seltag[arg.i] = !seltag[arg.i];
135	135		for(i = 0; i < ntags && !seltag[i]; i++);
136	136		if(i == ntags)
137		-	seltag[arg->i] = True; /* cannot toggle last view */
	137	+	seltag[arg.i] = True; /* cannot toggle last view */
138	138		lt->arrange();
139	139		}
140	140
141	141		void
142		-	view(Arg *arg) {
	142	+	view(Arg arg) {
143	143		unsigned int i;
144	144
145	145		for(i = 0; i < ntags; i++)
146		-	seltag[i] = (arg->i == -1) ? True : False;
147		-	if(arg->i >= 0 && arg->i < ntags)
148		-	seltag[arg->i] = True;
	146	+	seltag[i] = (arg.i == -1) ? True : False;
	147	+	if(arg.i >= 0 && arg.i < ntags)
	148	+	seltag[arg.i] = True;
149	149		lt->arrange();
150	150		}

30	30		}
31	31
32	32		void
33		-	spawn(Arg *arg) {
	33	+	spawn(Arg arg) {
34	34		static char *shell = NULL;
35	35
36	36		if(!shell && !(shell = getenv("SHELL")))
37	37		shell = "/bin/sh";
38		-	if(!arg->cmd)
	38	+	if(!arg.cmd)
39	39		return;
40	40		/* The double-fork construct avoids zombie processes and keeps the code
41	41		* clean from stupid signal handlers. */

44	44		if(dpy)
45	45		close(ConnectionNumber(dpy));
46	46		setsid();
47		-	execl(shell, shell, "-c", arg->cmd, (char *)NULL);
48		-	fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg->cmd);
	47	+	execl(shell, shell, "-c", arg.cmd, (char *)NULL);
	48	+	fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg.cmd);
49	49		perror(" failed");
50	50		}
51	51		exit(0);