git.stevedylan.dev

replaced Arg union with const char *arg, seems cleaner to me, even if we need atoi() in some places 2c477cf6

Anselm R. Garbe · 2007-02-22 11:42 9 file(s) · +189 −184

client.c +2 −2

}

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

}

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

config.arg.h +54 −54

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

config.default.h +51 −51

#define KEYS \
static Key key[] = { \
	/* modifier			key		function	argument */ \
	{ MODKEY|ShiftMask,		XK_Return,	spawn,		{ .cmd = "exec xterm" } }, \
	{ MODKEY,			XK_space,	setlayout,	{ .i = -1 } }, \
	{ MODKEY,			XK_d,		incnmaster,	{ .i = -1 } }, \
	{ MODKEY,			XK_i,		incnmaster,	{ .i = 1 } }, \
	{ MODKEY,			XK_h,		incmasterw,	{ .i = -15 } }, \
	{ MODKEY,			XK_l,		incmasterw,	{ .i = 15 } }, \
	{ MODKEY,			XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,			XK_k,		focusprev,	{ 0 } }, \
	{ MODKEY,			XK_m,		togglemax,	{ 0 } }, \
	{ MODKEY,			XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_space,	toggleversatile,{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_c,		killclient,	{ 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|ControlMask,		XK_1,		toggleview,	{ .i = 0 } }, \
	{ MODKEY|ControlMask,		XK_2,		toggleview,	{ .i = 1 } }, \
	{ MODKEY|ControlMask,		XK_3,		toggleview,	{ .i = 2 } }, \
	{ MODKEY|ControlMask,		XK_4,		toggleview,	{ .i = 3 } }, \
	{ MODKEY|ControlMask,		XK_5,		toggleview,	{ .i = 4 } }, \
	{ MODKEY|ControlMask,		XK_6,		toggleview,	{ .i = 5 } }, \
	{ MODKEY|ControlMask,		XK_7,		toggleview,	{ .i = 6 } }, \
	{ MODKEY|ControlMask,		XK_8,		toggleview,	{ .i = 7 } }, \
	{ MODKEY|ControlMask,		XK_9,		toggleview,	{ .i = 8 } }, \
	{ MODKEY|ShiftMask,		XK_0,		tag,		{ .i = -1 } }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		{ .i = 0 } }, \
	{ MODKEY|ShiftMask,		XK_2,		tag,		{ .i = 1 } }, \
	{ MODKEY|ShiftMask,		XK_3,		tag,		{ .i = 2 } }, \
	{ MODKEY|ShiftMask,		XK_4,		tag,		{ .i = 3 } }, \
	{ MODKEY|ShiftMask,		XK_5,		tag,		{ .i = 4 } }, \
	{ MODKEY|ShiftMask,		XK_6,		tag,		{ .i = 5 } }, \
	{ 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_q,		quit,		{ 0 } }, \
	{ MODKEY|ShiftMask,		XK_Return,	spawn,		"exec xterm" }, \
	{ MODKEY,			XK_space,	setlayout,	NULL }, \
	{ MODKEY,			XK_d,		incnmaster,	"-1" }, \
	{ MODKEY,			XK_i,		incnmaster,	"1" }, \
	{ MODKEY,			XK_h,		incmasterw,	"-15" }, \
	{ MODKEY,			XK_l,		incmasterw,	"15" }, \
	{ MODKEY,			XK_j,		focusnext,	NULL }, \
	{ MODKEY,			XK_k,		focusprev,	NULL }, \
	{ MODKEY,			XK_m,		togglemax,	NULL }, \
	{ MODKEY,			XK_Return,	zoom,		NULL }, \
	{ MODKEY|ShiftMask,		XK_space,	toggleversatile,NULL }, \
	{ MODKEY|ShiftMask,		XK_c,		killclient,	NULL }, \
	{ MODKEY,			XK_0,		view,		NULL }, \
	{ MODKEY,			XK_1,		view,		"0" }, \
	{ MODKEY,			XK_2,		view,		"1" }, \
	{ MODKEY,			XK_3,		view,		"2" }, \
	{ MODKEY,			XK_4,		view,		"3" }, \
	{ MODKEY,			XK_5,		view,		"4" }, \
	{ MODKEY,			XK_6,		view,		"5" }, \
	{ MODKEY,			XK_7,		view,		"6" }, \
	{ MODKEY,			XK_8,		view,		"7" }, \
	{ MODKEY,			XK_9,		view,		"8" }, \
	{ MODKEY|ControlMask,		XK_1,		toggleview,	"0" }, \
	{ MODKEY|ControlMask,		XK_2,		toggleview,	"1" }, \
	{ MODKEY|ControlMask,		XK_3,		toggleview,	"2" }, \
	{ MODKEY|ControlMask,		XK_4,		toggleview,	"3" }, \
	{ MODKEY|ControlMask,		XK_5,		toggleview,	"4" }, \
	{ MODKEY|ControlMask,		XK_6,		toggleview,	"5" }, \
	{ MODKEY|ControlMask,		XK_7,		toggleview,	"6" }, \
	{ MODKEY|ControlMask,		XK_8,		toggleview,	"7" }, \
	{ MODKEY|ControlMask,		XK_9,		toggleview,	"8" }, \
	{ MODKEY|ShiftMask,		XK_0,		tag,		NULL }, \
	{ MODKEY|ShiftMask,		XK_1,		tag,		"0" }, \
	{ MODKEY|ShiftMask,		XK_2,		tag,		"1" }, \
	{ MODKEY|ShiftMask,		XK_3,		tag,		"2" }, \
	{ MODKEY|ShiftMask,		XK_4,		tag,		"3" }, \
	{ MODKEY|ShiftMask,		XK_5,		tag,		"4" }, \
	{ MODKEY|ShiftMask,		XK_6,		tag,		"5" }, \
	{ MODKEY|ShiftMask,		XK_7,		tag,		"6" }, \
	{ MODKEY|ShiftMask,		XK_8,		tag,		"7" }, \
	{ MODKEY|ShiftMask,		XK_9,		tag,		"8" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_1,		toggletag,	"0" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_2,		toggletag,	"1" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_3,		toggletag,	"2" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_4,		toggletag,	"3" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_5,		toggletag,	"4" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_6,		toggletag,	"5" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_7,		toggletag,	"6" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_8,		toggletag,	"7" }, \
	{ MODKEY|ControlMask|ShiftMask,	XK_9,		toggletag,	"8" }, \
	{ MODKEY|ShiftMask,		XK_q,		quit,		NULL }, \
};

dwm.h +15 −20

enum { CurNormal, CurResize, CurMove, CurLast };	/* cursor */
enum { ColBorder, ColFG, ColBG, ColLast };		/* color */

typedef union {
	const char *cmd;
	int i;
} Arg; /* argument type */

typedef struct {
	int ascent;
	int descent;

extern void configure(Client *c);		/* send synthetic configure event */
extern void detach(Client *c);			/* detaches c from global client list */
extern void focus(Client *c);			/* focus c, c may be NULL */
extern void killclient(Arg arg);		/* kill c nicely */
extern void killclient(const char *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(const char *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 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 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 focusnext(const char *arg);		/* focuses next visible client, arg is ignored  */
extern void focusprev(const char *arg);		/* focuses previous visible client, arg is ignored */
extern void incmasterw(const char *arg);		/* increments the master width with arg's index value */
extern void incnmaster(const char *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 restack(void);			/* restores z layers of all clients */
extern void setlayout(Arg arg);		/* sets layout, -1 toggles */
extern void togglemax(Arg arg);			/* toggles maximization of versatile client */
extern void setlayout(const char *arg);		/* sets layout, -1 toggles */
extern void togglemax(const char *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(const char *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 zoom(Arg arg);			/* zooms the focused client to master area, arg is ignored */
extern void tag(const char *arg);			/* tags c with arg's index */
extern void toggletag(const char *arg);		/* toggles c tags with arg's index */
extern void toggleview(const char *arg);		/* toggles the tag with arg's index (in)visible */
extern void view(const char *arg);			/* views the tag with arg's index */
extern void zoom(const char *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(const char *arg);			/* forks a new subprocess with arg's cmd */


event.c +15 −13

 * See LICENSE file for license details.
 */
#include "dwm.h"
#include <stdio.h>
#include <stdlib.h>
#include <X11/keysym.h>
#include <X11/Xatom.h>

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

KEYS


static void
buttonpress(XEvent *e) {
	int x;
	Arg a;
	static char arg[8];
	int i, x;
	Client *c;
	XButtonPressedEvent *ev = &e->xbutton;

	arg[0] = 0;
	if(barwin == ev->window) {
		x = 0;
		for(a.i = 0; a.i < ntags; a.i++) {
			x += textw(tags[a.i]);
		for(i = 0; i < ntags; i++) {
			x += textw(tags[i]);
			if(ev->x < x) {
				snprintf(arg, sizeof arg, "%d", i);
				if(ev->button == Button1) {
					if(ev->state & MODKEY)
						tag(a);
						tag(arg);
					else
						view(a);
						view(arg);
				}
				else if(ev->button == Button3) {
					if(ev->state & MODKEY)
						toggletag(a);
						toggletag(arg);
					else
						toggleview(a);
						toggleview(arg);
				}
				return;
			}

		if(ev->x < x + blw)
			switch(ev->button) {
			case Button1:
				a.i = -1;
				setlayout(a);
				setlayout("-1");
				break;
			}
	}

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

layout.c +21 −17

/* extern */

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

}

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

	if(!sel)

}

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

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

}

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

	if(arg.i == -1) {
	if(!arg) {
		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)
		i = atoi(arg);
		if(i < 0 || i >= nlayouts)
			return;
		lt = &layout[arg.i];
		lt = &layout[i];
	}
	if(sel)
		lt->arrange();

}

void
togglemax(Arg arg) {
togglemax(const char *arg) {
	XEvent ev;

	if(!sel || (lt->arrange != versatile && !sel->isversatile) || sel->isfixed)

}

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


main.c +1 −1

}

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


tag.c +26 −22

}

void
tag(Arg arg) {
	unsigned int i;
tag(const char *arg) {
	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 ? False : True;
	i = arg ? atoi(arg) : 0;
	if(i >= 0 && i < ntags)
		sel->tags[i] = True;
	lt->arrange();
}

void
toggletag(Arg arg) {
	unsigned int i;
toggletag(const char *arg) {
	int i, j;

	if(!sel)
		return;
	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;
	i = arg ? atoi(arg) : 0;
	sel->tags[i] = !sel->tags[i];
	for(j = 0; j < ntags && !sel->tags[j]; j++);
	if(j == ntags)
		sel->tags[i] = True;
	lt->arrange();
}

void
toggleview(Arg arg) {
	unsigned int i;
toggleview(const char *arg) {
	int i, j;

	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 */
	i = arg ? atoi(arg) : 0;
	seltag[i] = !seltag[i];
	for(j = 0; j < ntags && !seltag[j]; i++);
	if(j == ntags)
		seltag[i] = True; /* cannot toggle last view */
	lt->arrange();
}

void
view(Arg arg) {
	unsigned int i;
view(const char *arg) {
	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 ? False : True;
	i = arg ? atoi(arg) : 0;
	if(i >= 0 && i < ntags)
		seltag[i] = True;
	lt->arrange();
}

util.c +4 −4

}

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

	if(!shell && !(shell = getenv("SHELL")))
		shell = "/bin/sh";
	if(!arg.cmd)
	if(!arg)
		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, (char *)NULL);
			fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg);
			perror(" failed");
		}
		exit(0);

153	153		}
154	154
155	155		void
156		-	killclient(Arg arg) {
	156	+	killclient(const char *arg) {
157	157		if(!sel)
158	158		return;
159	159		if(isprotodel(sel))

285	285		}
286	286
287	287		void
288		-	toggleversatile(Arg arg) {
	288	+	toggleversatile(const char *arg) {
289	289		if(!sel \|\| lt->arrange == versatile)
290	290		return;
291	291		sel->isversatile = !sel->isversatile;

41	41		enum { CurNormal, CurResize, CurMove, CurLast }; /* cursor */
42	42		enum { ColBorder, ColFG, ColBG, ColLast }; /* color */
43	43
44		-	typedef union {
45		-	const char *cmd;
46		-	int i;
47		-	} Arg; /* argument type */
48		-
49	44		typedef struct {
50	45		int ascent;
51	46		int descent;

106	101		extern void configure(Client c); / send synthetic configure event */
107	102		extern void detach(Client c); / detaches c from global client list */
108	103		extern void focus(Client c); / focus c, c may be NULL */
109		-	extern void killclient(Arg arg); /* kill c nicely */
	104	+	extern void killclient(const char arg); / kill c nicely */
110	105		extern void manage(Window w, XWindowAttributes wa); / manage new client */
111	106		extern void resize(Client *c, int x, int y,
112	107		int w, int h, Bool sizehints); /* resize with given coordinates c*/
113		-	extern void toggleversatile(Arg arg); /* toggles focused client between versatile/and non-versatile state */
	108	+	extern void toggleversatile(const char arg); / toggles focused client between versatile/and non-versatile state */
114	109		extern void updatesizehints(Client c); / update the size hint variables of c */
115	110		extern void updatetitle(Client c); / update the name of c */
116	111		extern void unmanage(Client c); / destroy c */

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

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

2	2		* See LICENSE file for license details.
3	3		*/
4	4		#include "dwm.h"
	5	+	#include <stdio.h>
5	6		#include <stdlib.h>
6	7		#include <X11/keysym.h>
7	8		#include <X11/Xatom.h>

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

112	113
113	114		static void
114	115		buttonpress(XEvent *e) {
115		-	int x;
116		-	Arg a;
	116	+	static char arg[8];
	117	+	int i, x;
117	118		Client *c;
118	119		XButtonPressedEvent *ev = &e->xbutton;
119	120
	121	+	arg[0] = 0;
120	122		if(barwin == ev->window) {
121	123		x = 0;
122		-	for(a.i = 0; a.i < ntags; a.i++) {
123		-	x += textw(tags[a.i]);
	124	+	for(i = 0; i < ntags; i++) {
	125	+	x += textw(tags[i]);
124	126		if(ev->x < x) {
	127	+	snprintf(arg, sizeof arg, "%d", i);
125	128		if(ev->button == Button1) {
126	129		if(ev->state & MODKEY)
127		-	tag(a);
	130	+	tag(arg);
128	131		else
129		-	view(a);
	132	+	view(arg);
130	133		}
131	134		else if(ev->button == Button3) {
132	135		if(ev->state & MODKEY)
133		-	toggletag(a);
	136	+	toggletag(arg);
134	137		else
135		-	toggleview(a);
	138	+	toggleview(arg);
136	139		}
137	140		return;
138	141		}

140	143		if(ev->x < x + blw)
141	144		switch(ev->button) {
142	145		case Button1:
143		-	a.i = -1;
144		-	setlayout(a);
	146	+	setlayout("-1");
145	147		break;
146	148		}
147	149		}

154	156		movemouse(c);
155	157		}
156	158		else if(ev->button == Button2)
157		-	zoom(a);
	159	+	zoom(NULL);
158	160		else if(ev->button == Button3
159	161		&& (lt->arrange == versatile \|\| c->isversatile) && !c->isfixed)
160	162		{

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

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

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

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

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

192	196		}
193	197
194	198		void
195		-	togglemax(Arg arg) {
	199	+	togglemax(const char *arg) {
196	200		XEvent ev;
197	201
198	202		if(!sel \|\| (lt->arrange != versatile && !sel->isversatile) \|\| sel->isfixed)

234	238		}
235	239
236	240		void
237		-	zoom(Arg arg) {
	241	+	zoom(const char *arg) {
238	242		unsigned int n;
239	243		Client *c;
240	244

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

42	42		static Key key[] = { \
43	43		/* modifier key function argument */ \
44	44		{ MODKEY, XK_p, spawn, \
45		-	{ .cmd = "exe=\"$(lsx `echo $PATH \| sed 's/:/ /g'` \| sort -u " \
46		-	" \| dmenu -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' " \
47		-	"-sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"')\" && exec $exe" } }, \
	45	+	"exe=\"$(lsx `echo $PATH \| sed 's/:/ /g'` \| sort -u " \
	46	+	" \| dmenu -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' " \
	47	+	"-sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"')\" && exec $exe" }, \
48	48		{ MODKEY\|ShiftMask, XK_Return, spawn, \
49		-	{ .cmd = "exec urxvtcd -tr -bg '#292929' -fg '#eee' -cr '#eee' +sb -fn '"FONT"'" } }, \
50		-	{ MODKEY, XK_space, setlayout, { .i = -1 } }, \
51		-	{ MODKEY, XK_d, incnmaster, { .i = -1 } }, \
52		-	{ MODKEY, XK_i, incnmaster, { .i = 1 } }, \
53		-	{ MODKEY, XK_h, incmasterw, { .i = -15 } }, \
54		-	{ MODKEY, XK_l, incmasterw, { .i = 15 } }, \
55		-	{ MODKEY, XK_j, focusnext, { 0 } }, \
56		-	{ MODKEY, XK_k, focusprev, { 0 } }, \
57		-	{ MODKEY, XK_m, togglemax, { 0 } }, \
58		-	{ MODKEY, XK_Return, zoom, { 0 } }, \
59		-	{ MODKEY\|ShiftMask, XK_space, toggleversatile,{ 0 } }, \
60		-	{ MODKEY\|ShiftMask, XK_c, killclient, { 0 } }, \
61		-	{ MODKEY, XK_0, view, { .i = -1 } }, \
62		-	{ MODKEY, XK_1, view, { .i = 0 } }, \
63		-	{ MODKEY, XK_2, view, { .i = 1 } }, \
64		-	{ MODKEY, XK_3, view, { .i = 2 } }, \
65		-	{ MODKEY, XK_4, view, { .i = 3 } }, \
66		-	{ MODKEY, XK_5, view, { .i = 4 } }, \
67		-	{ MODKEY, XK_6, view, { .i = 5 } }, \
68		-	{ MODKEY, XK_7, view, { .i = 6 } }, \
69		-	{ MODKEY, XK_8, view, { .i = 7 } }, \
70		-	{ MODKEY, XK_9, view, { .i = 8 } }, \
71		-	{ MODKEY\|ControlMask, XK_1, toggleview, { .i = 0 } }, \
72		-	{ MODKEY\|ControlMask, XK_2, toggleview, { .i = 1 } }, \
73		-	{ MODKEY\|ControlMask, XK_3, toggleview, { .i = 2 } }, \
74		-	{ MODKEY\|ControlMask, XK_4, toggleview, { .i = 3 } }, \
75		-	{ MODKEY\|ControlMask, XK_5, toggleview, { .i = 4 } }, \
76		-	{ MODKEY\|ControlMask, XK_6, toggleview, { .i = 5 } }, \
77		-	{ MODKEY\|ControlMask, XK_7, toggleview, { .i = 6 } }, \
78		-	{ MODKEY\|ControlMask, XK_8, toggleview, { .i = 7 } }, \
79		-	{ MODKEY\|ControlMask, XK_9, toggleview, { .i = 8 } }, \
80		-	{ MODKEY\|ShiftMask, XK_0, tag, { .i = -1 } }, \
81		-	{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \
82		-	{ MODKEY\|ShiftMask, XK_2, tag, { .i = 1 } }, \
83		-	{ MODKEY\|ShiftMask, XK_3, tag, { .i = 2 } }, \
84		-	{ MODKEY\|ShiftMask, XK_4, tag, { .i = 3 } }, \
85		-	{ MODKEY\|ShiftMask, XK_5, tag, { .i = 4 } }, \
86		-	{ MODKEY\|ShiftMask, XK_6, tag, { .i = 5 } }, \
87		-	{ MODKEY\|ShiftMask, XK_7, tag, { .i = 6 } }, \
88		-	{ MODKEY\|ShiftMask, XK_8, tag, { .i = 7 } }, \
89		-	{ MODKEY\|ShiftMask, XK_9, tag, { .i = 8 } }, \
90		-	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, { .i = 0 } }, \
91		-	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, { .i = 1 } }, \
92		-	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, { .i = 2 } }, \
93		-	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, { .i = 3 } }, \
94		-	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, { .i = 4 } }, \
95		-	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, { .i = 5 } }, \
96		-	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, { .i = 6 } }, \
97		-	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, { .i = 7 } }, \
98		-	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, { .i = 8 } }, \
99		-	{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
	49	+	"exec urxvtcd -tr -bg '#292929' -fg '#eee' -cr '#eee' +sb -fn '"FONT"'" }, \
	50	+	{ MODKEY, XK_space, setlayout, NULL }, \
	51	+	{ MODKEY, XK_d, incnmaster, "-1" }, \
	52	+	{ MODKEY, XK_i, incnmaster, "1" }, \
	53	+	{ MODKEY, XK_h, incmasterw, "-15" }, \
	54	+	{ MODKEY, XK_l, incmasterw, "15" }, \
	55	+	{ MODKEY, XK_j, focusnext, NULL }, \
	56	+	{ MODKEY, XK_k, focusprev, NULL }, \
	57	+	{ MODKEY, XK_m, togglemax, NULL }, \
	58	+	{ MODKEY, XK_Return, zoom, NULL }, \
	59	+	{ MODKEY\|ShiftMask, XK_space, toggleversatile,NULL }, \
	60	+	{ MODKEY\|ShiftMask, XK_c, killclient, NULL }, \
	61	+	{ MODKEY, XK_0, view, NULL }, \
	62	+	{ MODKEY, XK_1, view, "0" }, \
	63	+	{ MODKEY, XK_2, view, "1" }, \
	64	+	{ MODKEY, XK_3, view, "2" }, \
	65	+	{ MODKEY, XK_4, view, "3" }, \
	66	+	{ MODKEY, XK_5, view, "4" }, \
	67	+	{ MODKEY, XK_6, view, "5" }, \
	68	+	{ MODKEY, XK_7, view, "6" }, \
	69	+	{ MODKEY, XK_8, view, "7" }, \
	70	+	{ MODKEY, XK_9, view, "8" }, \
	71	+	{ MODKEY\|ControlMask, XK_1, toggleview, "0" }, \
	72	+	{ MODKEY\|ControlMask, XK_2, toggleview, "1" }, \
	73	+	{ MODKEY\|ControlMask, XK_3, toggleview, "2" }, \
	74	+	{ MODKEY\|ControlMask, XK_4, toggleview, "3" }, \
	75	+	{ MODKEY\|ControlMask, XK_5, toggleview, "4" }, \
	76	+	{ MODKEY\|ControlMask, XK_6, toggleview, "5" }, \
	77	+	{ MODKEY\|ControlMask, XK_7, toggleview, "6" }, \
	78	+	{ MODKEY\|ControlMask, XK_8, toggleview, "7" }, \
	79	+	{ MODKEY\|ControlMask, XK_9, toggleview, "8" }, \
	80	+	{ MODKEY\|ShiftMask, XK_0, tag, NULL }, \
	81	+	{ MODKEY\|ShiftMask, XK_1, tag, "0" }, \
	82	+	{ MODKEY\|ShiftMask, XK_2, tag, "1" }, \
	83	+	{ MODKEY\|ShiftMask, XK_3, tag, "2" }, \
	84	+	{ MODKEY\|ShiftMask, XK_4, tag, "3" }, \
	85	+	{ MODKEY\|ShiftMask, XK_5, tag, "4" }, \
	86	+	{ MODKEY\|ShiftMask, XK_6, tag, "5" }, \
	87	+	{ MODKEY\|ShiftMask, XK_7, tag, "6" }, \
	88	+	{ MODKEY\|ShiftMask, XK_8, tag, "7" }, \
	89	+	{ MODKEY\|ShiftMask, XK_9, tag, "8" }, \
	90	+	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, "0" }, \
	91	+	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, "1" }, \
	92	+	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, "2" }, \
	93	+	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, "3" }, \
	94	+	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, "4" }, \
	95	+	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, "5" }, \
	96	+	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, "6" }, \
	97	+	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, "7" }, \
	98	+	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, "8" }, \
	99	+	{ MODKEY\|ShiftMask, XK_q, quit, NULL }, \
100	100		};

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_space, setlayout, { .i = -1 } }, \
47		-	{ MODKEY, XK_d, incnmaster, { .i = -1 } }, \
48		-	{ MODKEY, XK_i, incnmaster, { .i = 1 } }, \
49		-	{ MODKEY, XK_h, incmasterw, { .i = -15 } }, \
50		-	{ MODKEY, XK_l, incmasterw, { .i = 15 } }, \
51		-	{ MODKEY, XK_j, focusnext, { 0 } }, \
52		-	{ MODKEY, XK_k, focusprev, { 0 } }, \
53		-	{ MODKEY, XK_m, togglemax, { 0 } }, \
54		-	{ MODKEY, XK_Return, zoom, { 0 } }, \
55		-	{ MODKEY\|ShiftMask, XK_space, toggleversatile,{ 0 } }, \
56		-	{ MODKEY\|ShiftMask, XK_c, killclient, { 0 } }, \
57		-	{ MODKEY, XK_0, view, { .i = -1 } }, \
58		-	{ MODKEY, XK_1, view, { .i = 0 } }, \
59		-	{ MODKEY, XK_2, view, { .i = 1 } }, \
60		-	{ MODKEY, XK_3, view, { .i = 2 } }, \
61		-	{ MODKEY, XK_4, view, { .i = 3 } }, \
62		-	{ MODKEY, XK_5, view, { .i = 4 } }, \
63		-	{ MODKEY, XK_6, view, { .i = 5 } }, \
64		-	{ MODKEY, XK_7, view, { .i = 6 } }, \
65		-	{ MODKEY, XK_8, view, { .i = 7 } }, \
66		-	{ MODKEY, XK_9, view, { .i = 8 } }, \
67		-	{ MODKEY\|ControlMask, XK_1, toggleview, { .i = 0 } }, \
68		-	{ MODKEY\|ControlMask, XK_2, toggleview, { .i = 1 } }, \
69		-	{ MODKEY\|ControlMask, XK_3, toggleview, { .i = 2 } }, \
70		-	{ MODKEY\|ControlMask, XK_4, toggleview, { .i = 3 } }, \
71		-	{ MODKEY\|ControlMask, XK_5, toggleview, { .i = 4 } }, \
72		-	{ MODKEY\|ControlMask, XK_6, toggleview, { .i = 5 } }, \
73		-	{ MODKEY\|ControlMask, XK_7, toggleview, { .i = 6 } }, \
74		-	{ MODKEY\|ControlMask, XK_8, toggleview, { .i = 7 } }, \
75		-	{ MODKEY\|ControlMask, XK_9, toggleview, { .i = 8 } }, \
76		-	{ MODKEY\|ShiftMask, XK_0, tag, { .i = -1 } }, \
77		-	{ MODKEY\|ShiftMask, XK_1, tag, { .i = 0 } }, \
78		-	{ MODKEY\|ShiftMask, XK_2, tag, { .i = 1 } }, \
79		-	{ MODKEY\|ShiftMask, XK_3, tag, { .i = 2 } }, \
80		-	{ MODKEY\|ShiftMask, XK_4, tag, { .i = 3 } }, \
81		-	{ MODKEY\|ShiftMask, XK_5, tag, { .i = 4 } }, \
82		-	{ MODKEY\|ShiftMask, XK_6, tag, { .i = 5 } }, \
83		-	{ MODKEY\|ShiftMask, XK_7, tag, { .i = 6 } }, \
84		-	{ MODKEY\|ShiftMask, XK_8, tag, { .i = 7 } }, \
85		-	{ MODKEY\|ShiftMask, XK_9, tag, { .i = 8 } }, \
86		-	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, { .i = 0 } }, \
87		-	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, { .i = 1 } }, \
88		-	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, { .i = 2 } }, \
89		-	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, { .i = 3 } }, \
90		-	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, { .i = 4 } }, \
91		-	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, { .i = 5 } }, \
92		-	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, { .i = 6 } }, \
93		-	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, { .i = 7 } }, \
94		-	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, { .i = 8 } }, \
95		-	{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
	45	+	{ MODKEY\|ShiftMask, XK_Return, spawn, "exec xterm" }, \
	46	+	{ MODKEY, XK_space, setlayout, NULL }, \
	47	+	{ MODKEY, XK_d, incnmaster, "-1" }, \
	48	+	{ MODKEY, XK_i, incnmaster, "1" }, \
	49	+	{ MODKEY, XK_h, incmasterw, "-15" }, \
	50	+	{ MODKEY, XK_l, incmasterw, "15" }, \
	51	+	{ MODKEY, XK_j, focusnext, NULL }, \
	52	+	{ MODKEY, XK_k, focusprev, NULL }, \
	53	+	{ MODKEY, XK_m, togglemax, NULL }, \
	54	+	{ MODKEY, XK_Return, zoom, NULL }, \
	55	+	{ MODKEY\|ShiftMask, XK_space, toggleversatile,NULL }, \
	56	+	{ MODKEY\|ShiftMask, XK_c, killclient, NULL }, \
	57	+	{ MODKEY, XK_0, view, NULL }, \
	58	+	{ MODKEY, XK_1, view, "0" }, \
	59	+	{ MODKEY, XK_2, view, "1" }, \
	60	+	{ MODKEY, XK_3, view, "2" }, \
	61	+	{ MODKEY, XK_4, view, "3" }, \
	62	+	{ MODKEY, XK_5, view, "4" }, \
	63	+	{ MODKEY, XK_6, view, "5" }, \
	64	+	{ MODKEY, XK_7, view, "6" }, \
	65	+	{ MODKEY, XK_8, view, "7" }, \
	66	+	{ MODKEY, XK_9, view, "8" }, \
	67	+	{ MODKEY\|ControlMask, XK_1, toggleview, "0" }, \
	68	+	{ MODKEY\|ControlMask, XK_2, toggleview, "1" }, \
	69	+	{ MODKEY\|ControlMask, XK_3, toggleview, "2" }, \
	70	+	{ MODKEY\|ControlMask, XK_4, toggleview, "3" }, \
	71	+	{ MODKEY\|ControlMask, XK_5, toggleview, "4" }, \
	72	+	{ MODKEY\|ControlMask, XK_6, toggleview, "5" }, \
	73	+	{ MODKEY\|ControlMask, XK_7, toggleview, "6" }, \
	74	+	{ MODKEY\|ControlMask, XK_8, toggleview, "7" }, \
	75	+	{ MODKEY\|ControlMask, XK_9, toggleview, "8" }, \
	76	+	{ MODKEY\|ShiftMask, XK_0, tag, NULL }, \
	77	+	{ MODKEY\|ShiftMask, XK_1, tag, "0" }, \
	78	+	{ MODKEY\|ShiftMask, XK_2, tag, "1" }, \
	79	+	{ MODKEY\|ShiftMask, XK_3, tag, "2" }, \
	80	+	{ MODKEY\|ShiftMask, XK_4, tag, "3" }, \
	81	+	{ MODKEY\|ShiftMask, XK_5, tag, "4" }, \
	82	+	{ MODKEY\|ShiftMask, XK_6, tag, "5" }, \
	83	+	{ MODKEY\|ShiftMask, XK_7, tag, "6" }, \
	84	+	{ MODKEY\|ShiftMask, XK_8, tag, "7" }, \
	85	+	{ MODKEY\|ShiftMask, XK_9, tag, "8" }, \
	86	+	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, "0" }, \
	87	+	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, "1" }, \
	88	+	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, "2" }, \
	89	+	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, "3" }, \
	90	+	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, "4" }, \
	91	+	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, "5" }, \
	92	+	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, "6" }, \
	93	+	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, "7" }, \
	94	+	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, "8" }, \
	95	+	{ MODKEY\|ShiftMask, XK_q, quit, NULL }, \
96	96		};

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

30	30		}
31	31
32	32		void
33		-	spawn(Arg arg) {
	33	+	spawn(const char *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)
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, (char *)NULL);
	48	+	fprintf(stderr, "dwm: execl '%s -c %s'", shell, arg);
49	49		perror(" failed");
50	50		}
51	51		exit(0);