git.stevedylan.dev

some experimental state DO NOT USE THIS, I plan to have a nicer interface to change geometries 33b19602

Anselm R Garbe · 2008-03-14 17:17 3 file(s) · +97 −195

config.anselm.h (deleted) +0 −154

/* See LICENSE file for copyright and license details. */

/* appearance */
#define BORDERPX		1
#define FONT			"-*-terminus-medium-r-normal-*-14-*-*-*-*-*-*-*"
#define NORMBORDERCOLOR		"#cccccc"
#define NORMBGCOLOR		"#cccccc"
#define NORMFGCOLOR		"#000000"
#define SELBORDERCOLOR		"#0066ff"
#define SELBGCOLOR		"#0066ff"
#define SELFGCOLOR		"#ffffff"

/* tagging */
const char tags[][MAXTAGLEN] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };

Rule rules[] = {
	/* class	instance	title		tags ref	isfloating */
	{ NULL,		NULL,		"Firefox",	tags[8],	False },
	{ NULL,		NULL,		"Gimp",		NULL,		True },
	{ NULL,		NULL,		"MPlayer",	NULL,		True },
	{ NULL,		NULL,		"Acroread",	NULL,		True },
};

/* geometry function */
void (*setgeoms)(void) = setdefgeoms;

void
setanselmgeoms(void) {

	/* screen dimensions */
	sx = 0;
	sy = 0;
	sw = DisplayWidth(dpy, screen);
	sh = DisplayHeight(dpy, screen);

	/* bar position */
	bx = sx;
	by = sy;
	bw = 1280;
	bh = dc.font.height + 2;

	/* window area */
	wx = sx;
	wy = sy + bh;
	ww = sw;
	wh = sh - bh;

	/* master area */
	mx = wx;
	my = wy;
	mw = 1280;
	mh = 800 - bh;

	/* tile area */
	tx = 1280;
	ty = 0;
	tw = sw - 1280;
	th = sh;

	/* monocle area */
	mox = mx;
	moy = my;
	mow = mw;
	moh = mh;
}

void
anselmgeoms(const char *arg) {
	setgeoms = setanselmgeoms;
	setgeoms();
	updatebarpos();
	setlayout("[]|");
}

void
defgeoms(const char *arg) {
	setgeoms = setdefgeoms;
	setgeoms();
	updatebarpos();
	setlayout("[]=");
}

/* layout(s) */
#define RESIZEHINTS		True	/* False - respect size hints in tiled resizals */
#define SNAP			32	/* snap pixel */

Layout layouts[] = {
	/* symbol		function	isfloating */
	{ "[]|",		tileh,		False }, /* first entry is default */
	{ "[]=",		tilev,		False },
	{ "><>",		floating,	True },
	{ "[M]",		monocle,	True },
};

/* key definitions */
#define MODKEY			Mod1Mask
Key keys[] = {
	/* modifier			key		function	argument */
	{ MODKEY,			XK_p,		spawn,
		"exec dmenu_run -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' -sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"' -x 0 -y 0 -w 1280" },
	{ MODKEY|ShiftMask,		XK_Return,	spawn, "exec uxterm" },
	{ MODKEY,			XK_a,		anselmgeoms,	NULL },
	{ MODKEY,			XK_d,		defgeoms,	NULL },
	{ MODKEY,			XK_j,		focusnext,	NULL },
	{ MODKEY,			XK_k,		focusprev,	NULL },
	{ MODKEY,			XK_r,		reapply,	NULL },
	{ MODKEY,			XK_Return,	zoom,		NULL },
	{ MODKEY,			XK_Tab,		viewprevtag,	NULL },
	{ MODKEY,			XK_m,		setlayout,	"[M]" },
	{ MODKEY,			XK_f,		setlayout,	"><>" },
	{ MODKEY,			XK_v,		setlayout,	"[]=" },
	{ MODKEY,			XK_h,		setlayout,	"[]|" },
	{ MODKEY|ShiftMask,		XK_space,	togglefloating,	NULL },
	{ MODKEY|ShiftMask,		XK_c,		killclient,	NULL },
	{ MODKEY,			XK_0,		view,		NULL },
	{ MODKEY,			XK_1,		view,		tags[0] },
	{ MODKEY,			XK_2,		view,		tags[1] },
	{ MODKEY,			XK_3,		view,		tags[2] },
	{ MODKEY,			XK_4,		view,		tags[3] },
	{ MODKEY,			XK_5,		view,		tags[4] },
	{ MODKEY,			XK_6,		view,		tags[5] },
	{ MODKEY,			XK_7,		view,		tags[6] },
	{ MODKEY,			XK_8,		view,		tags[7] },
	{ MODKEY,			XK_9,		view,		tags[8] },
	{ MODKEY|ControlMask,		XK_1,		toggleview,	tags[0] },
	{ MODKEY|ControlMask,		XK_2,		toggleview,	tags[1] },
	{ MODKEY|ControlMask,		XK_3,		toggleview,	tags[2] },
	{ MODKEY|ControlMask,		XK_4,		toggleview,	tags[3] },
	{ MODKEY|ControlMask,		XK_5,		toggleview,	tags[4] },
	{ MODKEY|ControlMask,		XK_6,		toggleview,	tags[5] },
	{ MODKEY|ControlMask,		XK_7,		toggleview,	tags[6] },
	{ MODKEY|ControlMask,		XK_8,		toggleview,	tags[7] },
	{ MODKEY|ControlMask,		XK_9,		toggleview,	tags[8] },
	{ MODKEY|ShiftMask,		XK_0,		tag,		NULL },
	{ MODKEY|ShiftMask,		XK_1,		tag,		tags[0] },
	{ MODKEY|ShiftMask,		XK_2,		tag,		tags[1] },
	{ MODKEY|ShiftMask,		XK_3,		tag,		tags[2] },
	{ MODKEY|ShiftMask,		XK_4,		tag,		tags[3] },
	{ MODKEY|ShiftMask,		XK_5,		tag,		tags[4] },
	{ MODKEY|ShiftMask,		XK_6,		tag,		tags[5] },
	{ MODKEY|ShiftMask,		XK_7,		tag,		tags[6] },
	{ MODKEY|ShiftMask,		XK_8,		tag,		tags[7] },
	{ MODKEY|ShiftMask,		XK_9,		tag,		tags[8] },
	{ MODKEY|ControlMask|ShiftMask,	XK_1,		toggletag,	tags[0] },
	{ MODKEY|ControlMask|ShiftMask,	XK_2,		toggletag,	tags[1] },
	{ MODKEY|ControlMask|ShiftMask,	XK_3,		toggletag,	tags[2] },
	{ MODKEY|ControlMask|ShiftMask,	XK_4,		toggletag,	tags[3] },
	{ MODKEY|ControlMask|ShiftMask,	XK_5,		toggletag,	tags[4] },
	{ MODKEY|ControlMask|ShiftMask,	XK_6,		toggletag,	tags[5] },
	{ MODKEY|ControlMask|ShiftMask,	XK_7,		toggletag,	tags[6] },
	{ MODKEY|ControlMask|ShiftMask,	XK_8,		toggletag,	tags[7] },
	{ MODKEY|ControlMask|ShiftMask,	XK_9,		toggletag,	tags[8] },
	{ MODKEY|ShiftMask,		XK_q,		quit,		NULL },
};

config.def.h +3 −3

#define SELBORDERCOLOR		"#0066ff"
#define SELBGCOLOR		"#0066ff"
#define SELFGCOLOR		"#ffffff"
#define GEOMETRY		"0 0 W B 0 B W H-B 0 B W*0.55 H-B W*0.45 B H-B 0 B W H-B"

/* tagging */
const char tags[][MAXTAGLEN] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };

	{ NULL,		NULL,		"MPlayer",	NULL,		True },
	{ NULL,		NULL,		"Acroread",	NULL,		True },
};

/* geometry function */
void (*setgeoms)(void) = setdefgeoms;

/* layout(s) */
#define RESIZEHINTS		True	/* False - respect size hints in tiled resizals */

#define MODKEY			Mod1Mask
Key keys[] = {
	/* modifier			key		function	argument */
	{ MODKEY,			XK_a,		setgeom,	"0 0 W B 0 B W H-B 0 B 1280 800-B 1280 0 W-1280 H 0 B 1280 800-B" },
	{ MODKEY,			XK_d,		setgeom,	GEOMETRY },
	{ MODKEY,			XK_p,		spawn,
		"exec dmenu_run -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' -sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"'" },
	{ MODKEY|ShiftMask,		XK_Return,	spawn, "exec uxterm" },

dwm.c +94 −38

void focusprev(const char *arg);
Client *getclient(Window w);
unsigned long getcolor(const char *colstr);
double getdouble(const char *s);
long getstate(Window w);
Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
void grabbuttons(Client *c, Bool focused);

void run(void);
void scan(void);
void setclientstate(Client *c, long state);
void setdefgeoms(void);
void setgeom(const char *arg);
void setlayout(const char *arg);
void setup(void);
void spawn(const char *arg);

	XConfigureEvent *ev = &e->xconfigure;

	if(ev->window == root && (ev->width != sw || ev->height != sh)) {
		setgeoms();
		setgeom(NULL);
		updatebarpos();
		arrange();
	}

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

void
setdefgeoms(void) {
/**
 * Idea:
 *
 * having a geom syntax as follows, which is interpreted as integer.
 *
 * [-,+][<0..n>|<W,H,B>]
 *
 *
 * B = bar height, W = DisplayWidth(), H = DisplayHeight()
 *
 * -/+/* /: is relative to current
 *
 * Then we would come down with <bx>,<by>,<bw>,<bh>,...
 *
 * "0 0 W B 0 0 W W N E B,W,B,
 *
 *
 */

	/* screen dimensions */
	sx = 0;
	sy = 0;
	sw = DisplayWidth(dpy, screen);
	sh = DisplayHeight(dpy, screen);
double
getdouble(const char *s) {
	char *endp;
	double result = 0;

	/* bar position */
	bx = sx;
	by = sy;
	bw = sw;
	bh = dc.font.height + 2;
	fprintf(stderr, "getdouble '%s'\n", s);
	switch(*s) {
	default: 
		result = strtod(s, &endp);
		if(s == endp || *endp != 0)
			result = strtol(s, &endp, 0);
		break;
	case 'B': result = dc.font.height + 2; break;
	case 'W': result = sw; break;
	case 'H': result = sh; break;
	}
	fprintf(stderr, "getdouble returns '%f'\n", result);
	return result;
}

	/* window area */
	wx = sx;
	wy = sy + bh;
	ww = sw;
	wh = sh - bh;
void
setgeom(const char *arg) {
	static const char *lastArg = NULL;
	char op, *s, *e, *p;
	double val;
	int i, *map[] = { &bx,  &by,  &bw,  &bh,
	                  &wx,  &wy,  &ww,  &wh,
	                  &mx,  &my,  &mw,  &mh,
	                  &tx,  &ty,  &tw,  &th,
	                  &mox, &moy, &mow, &moh };

	/* master area */
	mx = wx;
	my = wy;
	mw = ((float)sw) * 0.55;
	mh = wh;

	/* tile area */
	tx = mx + mw;
	ty = wy;
	tw = ww - mw;
	th = wh;

	/* monocle area */
	mox = wx;
	moy = wy;
	mow = ww;
	moh = wh;
	if(!arg)
		arg = lastArg;
	else
		lastArg = arg;
	if(!lastArg)
		return;
	strncpy(buf, arg, sizeof buf);
	for(i = 0, e = s = buf; e && *e; e++)
		if(*e == ' ') {
			*e = 0;
			fprintf(stderr, "next geom arg='%s'\n", s);
			op = 0;
			/* check if there is an operator */
			for(p = s; *p && *p != '-' && *p != '+' && *p != '*' && *p != ':'; p++);
			if(*p) {
				op = *p;
				*p = 0;
			}
			val = getdouble(s);
			fprintf(stderr, "val1: %d\n", val);
			if(p > s) { /* intermediate operand, e.g. H-B */
				*(map[i]) = val;
				s = ++p;
				val = getdouble(s);
				fprintf(stderr, "val2: %d\n", val);
			}
			switch(op) {
			default: *(map[i])   = val; break;
			case '-': *(map[i]) -= val; break;
			case '+': *(map[i]) += val; break;
			case '*': *(map[i]) *= val; break;
			case ':': if(val != 0) *(map[i]) /= val; break;
			}
			fprintf(stderr, "map[i]='%d'\n", val);
			s = ++e;
			i++;
		}
	updatebarpos();
	arrange();
}

void

	root = RootWindow(dpy, screen);
	initfont(FONT);

	/* apply default geometries */
	setgeoms();
	/* apply default dimensions */
	sx = 0;
	sy = 0;
	sw = DisplayWidth(dpy, screen);
	sh = DisplayHeight(dpy, screen);
	setgeom(GEOMETRY);

	/* init atoms */
	wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);

136	136		void focusprev(const char *arg);
137	137		Client *getclient(Window w);
138	138		unsigned long getcolor(const char *colstr);
	139	+	double getdouble(const char *s);
139	140		long getstate(Window w);
140	141		Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
141	142		void grabbuttons(Client *c, Bool focused);

163	164		void run(void);
164	165		void scan(void);
165	166		void setclientstate(Client *c, long state);
166		-	void setdefgeoms(void);
	167	+	void setgeom(const char *arg);
167	168		void setlayout(const char *arg);
168	169		void setup(void);
169	170		void spawn(const char *arg);

410	411		XConfigureEvent *ev = &e->xconfigure;
411	412
412	413		if(ev->window == root && (ev->width != sw \|\| ev->height != sh)) {
413		-	setgeoms();
	414	+	setgeom(NULL);
414	415		updatebarpos();
415	416		arrange();
416	417		}

1390	1391		PropModeReplace, (unsigned char *)data, 2);
1391	1392		}
1392	1393
1393		-	void
1394		-	setdefgeoms(void) {
	1394	+	/**
	1395	+	* Idea:
	1396	+	*
	1397	+	* having a geom syntax as follows, which is interpreted as integer.
	1398	+	*
	1399	+	* [-,+][<0..n>\|<W,H,B>]
	1400	+	*
	1401	+	*
	1402	+	* B = bar height, W = DisplayWidth(), H = DisplayHeight()
	1403	+	*
	1404	+	* -/+/* /: is relative to current
	1405	+	*
	1406	+	* Then we would come down with <bx>,<by>,<bw>,<bh>,...
	1407	+	*
	1408	+	* "0 0 W B 0 0 W W N E B,W,B,
	1409	+	*
	1410	+	*
	1411	+	*/
1395	1412
1396		-	/* screen dimensions */
1397		-	sx = 0;
1398		-	sy = 0;
1399		-	sw = DisplayWidth(dpy, screen);
1400		-	sh = DisplayHeight(dpy, screen);
	1413	+	double
	1414	+	getdouble(const char *s) {
	1415	+	char *endp;
	1416	+	double result = 0;
1401	1417
1402		-	/* bar position */
1403		-	bx = sx;
1404		-	by = sy;
1405		-	bw = sw;
1406		-	bh = dc.font.height + 2;
	1418	+	fprintf(stderr, "getdouble '%s'\n", s);
	1419	+	switch(*s) {
	1420	+	default:
	1421	+	result = strtod(s, &endp);
	1422	+	if(s == endp \|\| *endp != 0)
	1423	+	result = strtol(s, &endp, 0);
	1424	+	break;
	1425	+	case 'B': result = dc.font.height + 2; break;
	1426	+	case 'W': result = sw; break;
	1427	+	case 'H': result = sh; break;
	1428	+	}
	1429	+	fprintf(stderr, "getdouble returns '%f'\n", result);
	1430	+	return result;
	1431	+	}
1407	1432
1408		-	/* window area */
1409		-	wx = sx;
1410		-	wy = sy + bh;
1411		-	ww = sw;
1412		-	wh = sh - bh;
	1433	+	void
	1434	+	setgeom(const char *arg) {
	1435	+	static const char *lastArg = NULL;
	1436	+	char op, s, e, *p;
	1437	+	double val;
	1438	+	int i, *map[] = { &bx, &by, &bw, &bh,
	1439	+	&wx, &wy, &ww, &wh,
	1440	+	&mx, &my, &mw, &mh,
	1441	+	&tx, &ty, &tw, &th,
	1442	+	&mox, &moy, &mow, &moh };
1413	1443
1414		-	/* master area */
1415		-	mx = wx;
1416		-	my = wy;
1417		-	mw = ((float)sw) * 0.55;
1418		-	mh = wh;
1419		-
1420		-	/* tile area */
1421		-	tx = mx + mw;
1422		-	ty = wy;
1423		-	tw = ww - mw;
1424		-	th = wh;
1425		-
1426		-	/* monocle area */
1427		-	mox = wx;
1428		-	moy = wy;
1429		-	mow = ww;
1430		-	moh = wh;
	1444	+	if(!arg)
	1445	+	arg = lastArg;
	1446	+	else
	1447	+	lastArg = arg;
	1448	+	if(!lastArg)
	1449	+	return;
	1450	+	strncpy(buf, arg, sizeof buf);
	1451	+	for(i = 0, e = s = buf; e && *e; e++)
	1452	+	if(*e == ' ') {
	1453	+	*e = 0;
	1454	+	fprintf(stderr, "next geom arg='%s'\n", s);
	1455	+	op = 0;
	1456	+	/* check if there is an operator */
	1457	+	for(p = s; p && p != '-' && p != '+' && p != '' && p != ':'; p++);
	1458	+	if(*p) {
	1459	+	op = *p;
	1460	+	*p = 0;
	1461	+	}
	1462	+	val = getdouble(s);
	1463	+	fprintf(stderr, "val1: %d\n", val);
	1464	+	if(p > s) { /* intermediate operand, e.g. H-B */
	1465	+	*(map[i]) = val;
	1466	+	s = ++p;
	1467	+	val = getdouble(s);
	1468	+	fprintf(stderr, "val2: %d\n", val);
	1469	+	}
	1470	+	switch(op) {
	1471	+	default: *(map[i]) = val; break;
	1472	+	case '-': *(map[i]) -= val; break;
	1473	+	case '+': *(map[i]) += val; break;
	1474	+	case '': (map[i]) *= val; break;
	1475	+	case ':': if(val != 0) *(map[i]) /= val; break;
	1476	+	}
	1477	+	fprintf(stderr, "map[i]='%d'\n", val);
	1478	+	s = ++e;
	1479	+	i++;
	1480	+	}
	1481	+	updatebarpos();
	1482	+	arrange();
1431	1483		}
1432	1484
1433	1485		void

1464	1516		root = RootWindow(dpy, screen);
1465	1517		initfont(FONT);
1466	1518
1467		-	/* apply default geometries */
1468		-	setgeoms();
	1519	+	/* apply default dimensions */
	1520	+	sx = 0;
	1521	+	sy = 0;
	1522	+	sw = DisplayWidth(dpy, screen);
	1523	+	sh = DisplayHeight(dpy, screen);
	1524	+	setgeom(GEOMETRY);
1469	1525
1470	1526		/* init atoms */
1471	1527		wmatom[WMProtocols] = XInternAtom(dpy, "WM_PROTOCOLS", False);

1	-	/* See LICENSE file for copyright and license details. */
2	-
3	-	/* appearance */
4	-	#define BORDERPX 1
5	-	#define FONT "--terminus-medium-r-normal--14-------*"
6	-	#define NORMBORDERCOLOR "#cccccc"
7	-	#define NORMBGCOLOR "#cccccc"
8	-	#define NORMFGCOLOR "#000000"
9	-	#define SELBORDERCOLOR "#0066ff"
10	-	#define SELBGCOLOR "#0066ff"
11	-	#define SELFGCOLOR "#ffffff"
12	-
13	-	/* tagging */
14	-	const char tags[][MAXTAGLEN] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" };
15	-
16	-	Rule rules[] = {
17	-	/* class instance title tags ref isfloating */
18	-	{ NULL, NULL, "Firefox", tags[8], False },
19	-	{ NULL, NULL, "Gimp", NULL, True },
20	-	{ NULL, NULL, "MPlayer", NULL, True },
21	-	{ NULL, NULL, "Acroread", NULL, True },
22	-	};
23	-
24	-	/* geometry function */
25	-	void (*setgeoms)(void) = setdefgeoms;
26	-
27	-	void
28	-	setanselmgeoms(void) {
29	-
30	-	/* screen dimensions */
31	-	sx = 0;
32	-	sy = 0;
33	-	sw = DisplayWidth(dpy, screen);
34	-	sh = DisplayHeight(dpy, screen);
35	-
36	-	/* bar position */
37	-	bx = sx;
38	-	by = sy;
39	-	bw = 1280;
40	-	bh = dc.font.height + 2;
41	-
42	-	/* window area */
43	-	wx = sx;
44	-	wy = sy + bh;
45	-	ww = sw;
46	-	wh = sh - bh;
47	-
48	-	/* master area */
49	-	mx = wx;
50	-	my = wy;
51	-	mw = 1280;
52	-	mh = 800 - bh;
53	-
54	-	/* tile area */
55	-	tx = 1280;
56	-	ty = 0;
57	-	tw = sw - 1280;
58	-	th = sh;
59	-
60	-	/* monocle area */
61	-	mox = mx;
62	-	moy = my;
63	-	mow = mw;
64	-	moh = mh;
65	-	}
66	-
67	-	void
68	-	anselmgeoms(const char *arg) {
69	-	setgeoms = setanselmgeoms;
70	-	setgeoms();
71	-	updatebarpos();
72	-	setlayout("[]\|");
73	-	}
74	-
75	-	void
76	-	defgeoms(const char *arg) {
77	-	setgeoms = setdefgeoms;
78	-	setgeoms();
79	-	updatebarpos();
80	-	setlayout("[]=");
81	-	}
82	-
83	-	/* layout(s) */
84	-	#define RESIZEHINTS True /* False - respect size hints in tiled resizals */
85	-	#define SNAP 32 /* snap pixel */
86	-
87	-	Layout layouts[] = {
88	-	/* symbol function isfloating */
89	-	{ "[]\|", tileh, False }, /* first entry is default */
90	-	{ "[]=", tilev, False },
91	-	{ "><>", floating, True },
92	-	{ "[M]", monocle, True },
93	-	};
94	-
95	-	/* key definitions */
96	-	#define MODKEY Mod1Mask
97	-	Key keys[] = {
98	-	/* modifier key function argument */
99	-	{ MODKEY, XK_p, spawn,
100	-	"exec dmenu_run -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' -sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"' -x 0 -y 0 -w 1280" },
101	-	{ MODKEY\|ShiftMask, XK_Return, spawn, "exec uxterm" },
102	-	{ MODKEY, XK_a, anselmgeoms, NULL },
103	-	{ MODKEY, XK_d, defgeoms, NULL },
104	-	{ MODKEY, XK_j, focusnext, NULL },
105	-	{ MODKEY, XK_k, focusprev, NULL },
106	-	{ MODKEY, XK_r, reapply, NULL },
107	-	{ MODKEY, XK_Return, zoom, NULL },
108	-	{ MODKEY, XK_Tab, viewprevtag, NULL },
109	-	{ MODKEY, XK_m, setlayout, "[M]" },
110	-	{ MODKEY, XK_f, setlayout, "><>" },
111	-	{ MODKEY, XK_v, setlayout, "[]=" },
112	-	{ MODKEY, XK_h, setlayout, "[]\|" },
113	-	{ MODKEY\|ShiftMask, XK_space, togglefloating, NULL },
114	-	{ MODKEY\|ShiftMask, XK_c, killclient, NULL },
115	-	{ MODKEY, XK_0, view, NULL },
116	-	{ MODKEY, XK_1, view, tags[0] },
117	-	{ MODKEY, XK_2, view, tags[1] },
118	-	{ MODKEY, XK_3, view, tags[2] },
119	-	{ MODKEY, XK_4, view, tags[3] },
120	-	{ MODKEY, XK_5, view, tags[4] },
121	-	{ MODKEY, XK_6, view, tags[5] },
122	-	{ MODKEY, XK_7, view, tags[6] },
123	-	{ MODKEY, XK_8, view, tags[7] },
124	-	{ MODKEY, XK_9, view, tags[8] },
125	-	{ MODKEY\|ControlMask, XK_1, toggleview, tags[0] },
126	-	{ MODKEY\|ControlMask, XK_2, toggleview, tags[1] },
127	-	{ MODKEY\|ControlMask, XK_3, toggleview, tags[2] },
128	-	{ MODKEY\|ControlMask, XK_4, toggleview, tags[3] },
129	-	{ MODKEY\|ControlMask, XK_5, toggleview, tags[4] },
130	-	{ MODKEY\|ControlMask, XK_6, toggleview, tags[5] },
131	-	{ MODKEY\|ControlMask, XK_7, toggleview, tags[6] },
132	-	{ MODKEY\|ControlMask, XK_8, toggleview, tags[7] },
133	-	{ MODKEY\|ControlMask, XK_9, toggleview, tags[8] },
134	-	{ MODKEY\|ShiftMask, XK_0, tag, NULL },
135	-	{ MODKEY\|ShiftMask, XK_1, tag, tags[0] },
136	-	{ MODKEY\|ShiftMask, XK_2, tag, tags[1] },
137	-	{ MODKEY\|ShiftMask, XK_3, tag, tags[2] },
138	-	{ MODKEY\|ShiftMask, XK_4, tag, tags[3] },
139	-	{ MODKEY\|ShiftMask, XK_5, tag, tags[4] },
140	-	{ MODKEY\|ShiftMask, XK_6, tag, tags[5] },
141	-	{ MODKEY\|ShiftMask, XK_7, tag, tags[6] },
142	-	{ MODKEY\|ShiftMask, XK_8, tag, tags[7] },
143	-	{ MODKEY\|ShiftMask, XK_9, tag, tags[8] },
144	-	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, tags[0] },
145	-	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, tags[1] },
146	-	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, tags[2] },
147	-	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, tags[3] },
148	-	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, tags[4] },
149	-	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, tags[5] },
150	-	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, tags[6] },
151	-	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, tags[7] },
152	-	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, tags[8] },
153	-	{ MODKEY\|ShiftMask, XK_q, quit, NULL },
154	-	};