git.stevedylan.dev

client.c +3 −1

	int i;

	c->tw = 0;
	for(i = 0; i < TLast; i++)
	for(i = 0; i < ntags; i++)
		if(c->tags[i])
			c->tw += textw(tags[i]);
	c->tw += textw(c->name);

	XSetWindowAttributes twa;

	c = emallocz(sizeof(Client));
	c->tags = emallocz(ntags * sizeof(Bool));
	c->win = w;
	c->x = c->tx = wa->x;
	c->y = c->ty = wa->y;

		if(!sel)
			sel = clients;
	}
	free(c->tags);
	free(c);

	XSync(dpy, False);

config.arg.h +23 −29

 * See LICENSE file for license details.
 */

enum { Tfnord, Tdev, Tnet, Twork, Tmisc, TLast };
#define TAGS \
const char *tags[TLast] = { \
	[Tfnord] = "fnord", \
	[Tdev] = "dev", \
	[Tnet] = "net", \
	[Twork] = "work", \
	[Tmisc] = "misc", \
};
const char *tags[] = { "fnord", "dev", "net", "work", "misc", NULL };

#define DEFMODE			dotile /* dofloat */
#define DEFTAG			Tdev
#define DEFTAG			1 /* index */
#define FONT			"-*-terminus-medium-*-*-*-13-*-*-*-*-*-iso10646-*"
#define BGCOLOR			"#0a2c2d"
#define FGCOLOR			"#ddeeee"

	const char *xlock[] = { "xlock", NULL }; \
static Key key[] = { \
	/* modifier		key		function	arguments */ \
	{ MODKEY,		XK_0,		view,		{ .i = Tfnord } }, \
	{ MODKEY,		XK_1,		view,		{ .i = Tdev } }, \
	{ MODKEY,		XK_2,		view,		{ .i = Tnet } }, \
	{ MODKEY,		XK_3,		view,		{ .i = Twork } }, \
	{ MODKEY,		XK_4,		view,		{ .i = Tmisc} }, \
	{ MODKEY,		XK_0,		view,		{ .i = 0 } }, \
	{ MODKEY,		XK_1,		view,		{ .i = 1 } }, \
	{ MODKEY,		XK_2,		view,		{ .i = 2 } }, \
	{ MODKEY,		XK_3,		view,		{ .i = 3 } }, \
	{ MODKEY,		XK_4,		view,		{ .i = 4 } }, \
	{ MODKEY,		XK_h,		viewprev,	{ 0 } }, \
	{ MODKEY,		XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,		XK_k,		focusprev,	{ 0 } }, \

	{ MODKEY,		XK_m,		togglemax,	{ 0 } }, \
	{ MODKEY,		XK_space,	togglemode,	{ 0 } }, \
	{ MODKEY,		XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY|ControlMask,	XK_0,		appendtag,	{ .i = Tfnord } }, \
	{ MODKEY|ControlMask,	XK_1,		appendtag,	{ .i = Tdev } }, \
	{ MODKEY|ControlMask,	XK_2,		appendtag,	{ .i = Tnet } }, \
	{ MODKEY|ControlMask,	XK_3,		appendtag,	{ .i = Twork } }, \
	{ MODKEY|ControlMask,	XK_4,		appendtag,	{ .i = Tmisc } }, \
	{ MODKEY|ShiftMask,	XK_0,		replacetag,	{ .i = Tfnord } }, \
	{ MODKEY|ShiftMask,	XK_1,		replacetag,	{ .i = Tdev } }, \
	{ MODKEY|ShiftMask,	XK_2,		replacetag,	{ .i = Tnet } }, \
	{ MODKEY|ShiftMask,	XK_3,		replacetag,	{ .i = Twork } }, \
	{ MODKEY|ShiftMask,	XK_4,		replacetag,	{ .i = Tmisc } }, \
	{ MODKEY|ControlMask,	XK_0,		appendtag,	{ .i = 0 } }, \
	{ MODKEY|ControlMask,	XK_1,		appendtag,	{ .i = 1 } }, \
	{ MODKEY|ControlMask,	XK_2,		appendtag,	{ .i = 2 } }, \
	{ MODKEY|ControlMask,	XK_3,		appendtag,	{ .i = 3 } }, \
	{ MODKEY|ControlMask,	XK_4,		appendtag,	{ .i = 4 } }, \
	{ MODKEY|ShiftMask,	XK_0,		replacetag,	{ .i = 0 } }, \
	{ MODKEY|ShiftMask,	XK_1,		replacetag,	{ .i = 1 } }, \
	{ MODKEY|ShiftMask,	XK_2,		replacetag,	{ .i = 2 } }, \
	{ MODKEY|ShiftMask,	XK_3,		replacetag,	{ .i = 3 } }, \
	{ MODKEY|ShiftMask,	XK_4,		replacetag,	{ .i = 5 } }, \
	{ MODKEY|ShiftMask,	XK_c,		killclient,	{ 0 } }, \
	{ MODKEY|ShiftMask,	XK_q,		quit,		{ 0 } }, \
	{ MODKEY|ShiftMask,	XK_Return,	spawn,		{ .argv = term } }, \

};

#define RULES \
	const unsigned int firefox[] = { 2 }; \
static Rule rule[] = { \
	/* class:instance	tags				isfloat */ \
	{ "Firefox.*",		{ [Tnet] = True },		False }, \
	{ "Gimp.*",		{ 0 },				True}, \
	{ "MPlayer.*",		{ 0 },				True}, \
	{ "Acroread.*",		{ 0 },				True}, \
	/* class:instance	tags		isfloat */ \
	{ "Firefox.*",		firefox,	False }, \
	{ "Gimp.*",		NULL,		True}, \
	{ "MPlayer.*",		NULL,		True}, \
	{ "Acroread.*",		NULL,		True}, \
};

config.default.h +21 −27

 * See LICENSE file for license details.
 */

enum { Tfnord, Tdev, Tnet, Twork, Tmisc, TLast };
#define TAGS \
const char *tags[TLast] = { \
	[Tfnord] = "fnord", \
	[Tdev] = "dev", \
	[Tnet] = "net", \
	[Twork] = "work", \
	[Tmisc] = "misc", \
};
const char *tags[] = { "0", "1", "2", "3", "4", NULL };

#define DEFMODE			dotile /* dofloat */
#define DEFTAG			Tdev
#define DEFTAG			1 /* index */
#define FONT			"fixed"
#define BGCOLOR			"#666699"
#define FGCOLOR			"#eeeeee"

	const char *term[] = { "xterm", NULL }; \
static Key key[] = { \
	/* modifier		key		function	arguments */ \
	{ MODKEY,		XK_0,		view,		{ .i = Tfnord } }, \
	{ MODKEY,		XK_1,		view,		{ .i = Tdev } }, \
	{ MODKEY,		XK_2,		view,		{ .i = Tnet } }, \
	{ MODKEY,		XK_3,		view,		{ .i = Twork } }, \
	{ MODKEY,		XK_4,		view,		{ .i = Tmisc} }, \
	{ MODKEY,		XK_0,		view,		{ .i = 0 } }, \
	{ MODKEY,		XK_1,		view,		{ .i = 1 } }, \
	{ MODKEY,		XK_2,		view,		{ .i = 2 } }, \
	{ MODKEY,		XK_3,		view,		{ .i = 3 } }, \
	{ MODKEY,		XK_4,		view,		{ .i = 4 } }, \
	{ MODKEY,		XK_h,		viewprev,	{ 0 } }, \
	{ MODKEY,		XK_j,		focusnext,	{ 0 } }, \
	{ MODKEY,		XK_k,		focusprev,	{ 0 } }, \

	{ MODKEY,		XK_m,		togglemax,	{ 0 } }, \
	{ MODKEY,		XK_space,	togglemode,	{ 0 } }, \
	{ MODKEY,		XK_Return,	zoom,		{ 0 } }, \
	{ MODKEY|ControlMask,	XK_0,		appendtag,	{ .i = Tfnord } }, \
	{ MODKEY|ControlMask,	XK_1,		appendtag,	{ .i = Tdev } }, \
	{ MODKEY|ControlMask,	XK_2,		appendtag,	{ .i = Tnet } }, \
	{ MODKEY|ControlMask,	XK_3,		appendtag,	{ .i = Twork } }, \
	{ MODKEY|ControlMask,	XK_4,		appendtag,	{ .i = Tmisc } }, \
	{ MODKEY|ShiftMask,	XK_0,		replacetag,	{ .i = Tfnord } }, \
	{ MODKEY|ShiftMask,	XK_1,		replacetag,	{ .i = Tdev } }, \
	{ MODKEY|ShiftMask,	XK_2,		replacetag,	{ .i = Tnet } }, \
	{ MODKEY|ShiftMask,	XK_3,		replacetag,	{ .i = Twork } }, \
	{ MODKEY|ShiftMask,	XK_4,		replacetag,	{ .i = Tmisc } }, \
	{ MODKEY|ControlMask,	XK_0,		appendtag,	{ .i = 0 } }, \
	{ MODKEY|ControlMask,	XK_1,		appendtag,	{ .i = 1 } }, \
	{ MODKEY|ControlMask,	XK_2,		appendtag,	{ .i = 2 } }, \
	{ MODKEY|ControlMask,	XK_3,		appendtag,	{ .i = 3 } }, \
	{ MODKEY|ControlMask,	XK_4,		appendtag,	{ .i = 4 } }, \
	{ MODKEY|ShiftMask,	XK_0,		replacetag,	{ .i = 0 } }, \
	{ MODKEY|ShiftMask,	XK_1,		replacetag,	{ .i = 1 } }, \
	{ MODKEY|ShiftMask,	XK_2,		replacetag,	{ .i = 2 } }, \
	{ MODKEY|ShiftMask,	XK_3,		replacetag,	{ .i = 3 } }, \
	{ MODKEY|ShiftMask,	XK_4,		replacetag,	{ .i = 4 } }, \
	{ MODKEY|ShiftMask,	XK_c,		killclient,	{ 0 } }, \
	{ MODKEY|ShiftMask,	XK_q,		quit,		{ 0 } }, \
	{ MODKEY|ShiftMask,	XK_Return,	spawn,		{ .argv = term } }, \
};

#define RULES \
	const unsigned int firefox[] = { 2 }; \
static Rule rule[] = { \
	/* class:instance	tags				isfloat */ \
	{ "Firefox.*",		{ [Tnet] = True },		False }, \
	{ "Gimp.*",		{ 0 },				True}, \
	/* class:instance	tags		isfloat */ \
	{ "Firefox.*",		firefox,	False }, \
	{ "Gimp.*",		NULL,		True}, \
};

draw.c +2 −2

114	114		drawtext(NULL, !istile, False);
115	115
116	116		dc.w = 0;
117		-	for(i = 0; i < TLast; i++) {
	117	+	for(i = 0; i < ntags; i++) {
118	118		dc.x += dc.w;
119	119		dc.w = textw(tags[i]);
120	120		if(istile)

153	153		dc.x = dc.y = 0;
154	154
155	155		dc.w = 0;
156		-	for(i = 0; i < TLast; i++) {
	156	+	for(i = 0; i < ntags; i++) {
157	157		if(c->tags[i]) {
158	158		dc.x += dc.w;
159	159		dc.w = textw(tags[i]);

dwm.h +3 −2

	unsigned int border;
	Bool isfloat;
	Bool ismax;
	Bool tags[TLast];
	Bool *tags;
	Client *next;
	Client *prev;
	Window win;
	Window title;
};

extern const char *tags[TLast];
extern const char *tags[];
extern char stext[1024];
extern int tsel, screen, sx, sy, sw, sh, bx, by, bw, bh, mw;
extern unsigned int ntags;
extern void (*handler[LASTEvent])(XEvent *);
extern void (*arrange)(Arg *);
extern Atom wmatom[WMLast], netatom[NetLast];

event.c +1 −1

105	105		switch(ev->button) {
106	106		default:
107	107		x = 0;
108		-	for(a.i = 0; a.i < TLast; a.i++) {
	108	+	for(a.i = 0; a.i < ntags; a.i++) {
109	109		x += textw(tags[a.i]);
110	110		if(ev->x < x) {
111	111		view(&a);

main.c +3 −0

char stext[1024];
int tsel = DEFTAG;
int screen, sx, sy, sw, sh, bx, by, bw, bh, mw;
unsigned int ntags;
Atom wmatom[WMLast], netatom[NetLast];
Bool running = True;
Bool issel = True;

	cursor[CurMove] = XCreateFontCursor(dpy, XC_fleur);

	grabkeys();

	for(ntags = 0; tags[ntags]; ntags++);

	/* style */
	dc.bg = getcolor(BGCOLOR);

tag.c +10 −9


typedef struct {
	const char *pattern;
	Bool tags[TLast];
	const unsigned int *tags;
	Bool isfloat;
} Rule;


	if(!sel)
		return;

	for(i = 0; i < TLast; i++)
	for(i = 0; i < ntags; i++)
		sel->tags[i] = False;
	appendtag(arg);
}

{
	char classinst[256];
	static unsigned int len = sizeof(rule) / sizeof(rule[0]);
	unsigned int i, j;
	unsigned int i, j, n;
	regex_t regex;
	regmatch_t tmp;
	Bool matched = False;

		for(i = 0; !matched && i < len; i++) {
			if(!regcomp(&regex, rule[i].pattern, 0)) {
				if(!regexec(&regex, classinst, 1, &tmp, 0)) {
					for(j = 0; j < TLast; j++) {
						if((c->tags[j] = rule[i].tags[j]))
							matched = True;
					}
					n = rule[i].tags ?
						sizeof(rule[i].tags) / sizeof(rule[i].tags[0]) : 0;
					matched = n != 0;
					for(j = 0; j < n; j++)
						c->tags[rule[i].tags[j]] = True;
					c->isfloat = rule[i].isfloat;
				}
				regfree(&regex);

void
viewnext(Arg *arg)
{
	arg->i = (tsel < TLast-1) ? tsel+1 : 0;
	arg->i = (tsel < ntags-1) ? tsel+1 : 0;
	view(arg);
}

void
viewprev(Arg *arg)
{
	arg->i = (tsel > 0) ? tsel-1 : TLast-1;
	arg->i = (tsel > 0) ? tsel-1 : ntags-1;
	view(arg);
}

60	60		unsigned int border;
61	61		Bool isfloat;
62	62		Bool ismax;
63		-	Bool tags[TLast];
	63	+	Bool *tags;
64	64		Client *next;
65	65		Client *prev;
66	66		Window win;
67	67		Window title;
68	68		};
69	69
70		-	extern const char *tags[TLast];
	70	+	extern const char *tags[];
71	71		extern char stext[1024];
72	72		extern int tsel, screen, sx, sy, sw, sh, bx, by, bw, bh, mw;
	73	+	extern unsigned int ntags;
73	74		extern void (handler[LASTEvent])(XEvent );
74	75		extern void (arrange)(Arg );
75	76		extern Atom wmatom[WMLast], netatom[NetLast];

85	85		char stext[1024];
86	86		int tsel = DEFTAG;
87	87		int screen, sx, sy, sw, sh, bx, by, bw, bh, mw;
	88	+	unsigned int ntags;
88	89		Atom wmatom[WMLast], netatom[NetLast];
89	90		Bool running = True;
90	91		Bool issel = True;

209	210		cursor[CurMove] = XCreateFontCursor(dpy, XC_fleur);
210	211
211	212		grabkeys();
	213	+
	214	+	for(ntags = 0; tags[ntags]; ntags++);
212	215
213	216		/* style */
214	217		dc.bg = getcolor(BGCOLOR);

16	16		int i;
17	17
18	18		c->tw = 0;
19		-	for(i = 0; i < TLast; i++)
	19	+	for(i = 0; i < ntags; i++)
20	20		if(c->tags[i])
21	21		c->tw += textw(tags[i]);
22	22		c->tw += textw(c->name);

211	211		XSetWindowAttributes twa;
212	212
213	213		c = emallocz(sizeof(Client));
	214	+	c->tags = emallocz(ntags * sizeof(Bool));
214	215		c->win = w;
215	216		c->x = c->tx = wa->x;
216	217		c->y = c->ty = wa->y;

429	430		if(!sel)
430	431		sel = clients;
431	432		}
	433	+	free(c->tags);
432	434		free(c);
433	435
434	436		XSync(dpy, False);

3	3		* See LICENSE file for license details.
4	4		*/
5	5
6		-	enum { Tfnord, Tdev, Tnet, Twork, Tmisc, TLast };
7	6		#define TAGS \
8		-	const char *tags[TLast] = { \
9		-	[Tfnord] = "fnord", \
10		-	[Tdev] = "dev", \
11		-	[Tnet] = "net", \
12		-	[Twork] = "work", \
13		-	[Tmisc] = "misc", \
14		-	};
	7	+	const char *tags[] = { "fnord", "dev", "net", "work", "misc", NULL };
15	8
16	9		#define DEFMODE dotile /* dofloat */
17		-	#define DEFTAG Tdev
	10	+	#define DEFTAG 1 /* index */
18	11		#define FONT "--terminus-medium----13------iso10646-"
19	12		#define BGCOLOR "#0a2c2d"
20	13		#define FGCOLOR "#ddeeee"

33	26		const char *xlock[] = { "xlock", NULL }; \
34	27		static Key key[] = { \
35	28		/* modifier key function arguments */ \
36		-	{ MODKEY, XK_0, view, { .i = Tfnord } }, \
37		-	{ MODKEY, XK_1, view, { .i = Tdev } }, \
38		-	{ MODKEY, XK_2, view, { .i = Tnet } }, \
39		-	{ MODKEY, XK_3, view, { .i = Twork } }, \
40		-	{ MODKEY, XK_4, view, { .i = Tmisc} }, \
	29	+	{ MODKEY, XK_0, view, { .i = 0 } }, \
	30	+	{ MODKEY, XK_1, view, { .i = 1 } }, \
	31	+	{ MODKEY, XK_2, view, { .i = 2 } }, \
	32	+	{ MODKEY, XK_3, view, { .i = 3 } }, \
	33	+	{ MODKEY, XK_4, view, { .i = 4 } }, \
41	34		{ MODKEY, XK_h, viewprev, { 0 } }, \
42	35		{ MODKEY, XK_j, focusnext, { 0 } }, \
43	36		{ MODKEY, XK_k, focusprev, { 0 } }, \

45	38		{ MODKEY, XK_m, togglemax, { 0 } }, \
46	39		{ MODKEY, XK_space, togglemode, { 0 } }, \
47	40		{ MODKEY, XK_Return, zoom, { 0 } }, \
48		-	{ MODKEY\|ControlMask, XK_0, appendtag, { .i = Tfnord } }, \
49		-	{ MODKEY\|ControlMask, XK_1, appendtag, { .i = Tdev } }, \
50		-	{ MODKEY\|ControlMask, XK_2, appendtag, { .i = Tnet } }, \
51		-	{ MODKEY\|ControlMask, XK_3, appendtag, { .i = Twork } }, \
52		-	{ MODKEY\|ControlMask, XK_4, appendtag, { .i = Tmisc } }, \
53		-	{ MODKEY\|ShiftMask, XK_0, replacetag, { .i = Tfnord } }, \
54		-	{ MODKEY\|ShiftMask, XK_1, replacetag, { .i = Tdev } }, \
55		-	{ MODKEY\|ShiftMask, XK_2, replacetag, { .i = Tnet } }, \
56		-	{ MODKEY\|ShiftMask, XK_3, replacetag, { .i = Twork } }, \
57		-	{ MODKEY\|ShiftMask, XK_4, replacetag, { .i = Tmisc } }, \
	41	+	{ MODKEY\|ControlMask, XK_0, appendtag, { .i = 0 } }, \
	42	+	{ MODKEY\|ControlMask, XK_1, appendtag, { .i = 1 } }, \
	43	+	{ MODKEY\|ControlMask, XK_2, appendtag, { .i = 2 } }, \
	44	+	{ MODKEY\|ControlMask, XK_3, appendtag, { .i = 3 } }, \
	45	+	{ MODKEY\|ControlMask, XK_4, appendtag, { .i = 4 } }, \
	46	+	{ MODKEY\|ShiftMask, XK_0, replacetag, { .i = 0 } }, \
	47	+	{ MODKEY\|ShiftMask, XK_1, replacetag, { .i = 1 } }, \
	48	+	{ MODKEY\|ShiftMask, XK_2, replacetag, { .i = 2 } }, \
	49	+	{ MODKEY\|ShiftMask, XK_3, replacetag, { .i = 3 } }, \
	50	+	{ MODKEY\|ShiftMask, XK_4, replacetag, { .i = 5 } }, \
58	51		{ MODKEY\|ShiftMask, XK_c, killclient, { 0 } }, \
59	52		{ MODKEY\|ShiftMask, XK_q, quit, { 0 } }, \
60	53		{ MODKEY\|ShiftMask, XK_Return, spawn, { .argv = term } }, \

64	57		};
65	58
66	59		#define RULES \
	60	+	const unsigned int firefox[] = { 2 }; \
67	61		static Rule rule[] = { \
68		-	/* class:instance tags isfloat */ \
69		-	{ "Firefox.*", { [Tnet] = True }, False }, \
70		-	{ "Gimp.*", { 0 }, True}, \
71		-	{ "MPlayer.*", { 0 }, True}, \
72		-	{ "Acroread.*", { 0 }, True}, \
	62	+	/* class:instance tags isfloat */ \
	63	+	{ "Firefox.*", firefox, False }, \
	64	+	{ "Gimp.*", NULL, True}, \
	65	+	{ "MPlayer.*", NULL, True}, \
	66	+	{ "Acroread.*", NULL, True}, \
73	67		};

13	13
14	14		typedef struct {
15	15		const char *pattern;
16		-	Bool tags[TLast];
	16	+	const unsigned int *tags;
17	17		Bool isfloat;
18	18		} Rule;
19	19

145	145		if(!sel)
146	146		return;
147	147
148		-	for(i = 0; i < TLast; i++)
	148	+	for(i = 0; i < ntags; i++)
149	149		sel->tags[i] = False;
150	150		appendtag(arg);
151	151		}

155	155		{
156	156		char classinst[256];
157	157		static unsigned int len = sizeof(rule) / sizeof(rule[0]);
158		-	unsigned int i, j;
	158	+	unsigned int i, j, n;
159	159		regex_t regex;
160	160		regmatch_t tmp;
161	161		Bool matched = False;

168	168		for(i = 0; !matched && i < len; i++) {
169	169		if(!regcomp(&regex, rule[i].pattern, 0)) {
170	170		if(!regexec(&regex, classinst, 1, &tmp, 0)) {
171		-	for(j = 0; j < TLast; j++) {
172		-	if((c->tags[j] = rule[i].tags[j]))
173		-	matched = True;
174		-	}
	171	+	n = rule[i].tags ?
	172	+	sizeof(rule[i].tags) / sizeof(rule[i].tags[0]) : 0;
	173	+	matched = n != 0;
	174	+	for(j = 0; j < n; j++)
	175	+	c->tags[rule[i].tags[j]] = True;
175	176		c->isfloat = rule[i].isfloat;
176	177		}
177	178		regfree(&regex);

204	205		void
205	206		viewnext(Arg *arg)
206	207		{
207		-	arg->i = (tsel < TLast-1) ? tsel+1 : 0;
	208	+	arg->i = (tsel < ntags-1) ? tsel+1 : 0;
208	209		view(arg);
209	210		}
210	211
211	212		void
212	213		viewprev(Arg *arg)
213	214		{
214		-	arg->i = (tsel > 0) ? tsel-1 : TLast-1;
	215	+	arg->i = (tsel > 0) ? tsel-1 : ntags-1;
215	216		view(arg);
216	217		}