git.stevedylan.dev

config.arg.h +3 −3

#define TAGS \
const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL };
#define RULES \
static Rule rule[] = { \
static Rule rules[] = { \
	/* class:instance:title regex	tags regex	isfloating */ \
	{ "Firefox",			"3",		False }, \
	{ "Gimp",			NULL,		True }, \

/* layout(s) */
#include "tile.h"
#define LAYOUTS \
static Layout layout[] = { \
static Layout layouts[] = { \
	/* symbol		function */ \
	{ "[]=",		tile }, /* first entry is default */ \
	{ "><>",		floating }, \

/* key definitions */
#define MODKEY			Mod1Mask
#define KEYS \
Key key[] = { \
Key keys[] = { \
	/* modifier			key		function	argument */ \
	{ MODKEY,			XK_p,		spawn, \
		"exe=`dmenu_path | dmenu -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"'" \

config.default.h +3 −3

/* Query class:instance:title for regex matching info with following command:
 * xprop | awk -F '"' '/^WM_CLASS/ { printf("%s:%s:",$4,$2) }; /^WM_NAME/ { printf("%s\n",$2) }' */
#define RULES \
static Rule rule[] = { \
static Rule rules[] = { \
	/* class:instance:title regex	tags regex	isfloating */ \
	{ "Gimp",			NULL,		True }, \
	{ "MPlayer",			NULL,		True }, \

/* layout(s) */
#include "tile.h"
#define LAYOUTS \
static Layout layout[] = { \
static Layout layouts[] = { \
	/* symbol		function */ \
	{ "[]=",		tile }, /* first entry is default */ \
	{ "><>",		floating }, \

/* key definitions */
#define MODKEY			Mod1Mask
#define KEYS \
Key key[] = { \
Key keys[] = { \
	/* modifier			key		function	argument */ \
	{ MODKEY|ShiftMask,		XK_Return,	spawn,		"exec xterm" }, \
	{ MODKEY,			XK_p,		spawn, 		"exe=`dmenu_path | dmenu` && exec $exe" }, \

event.c +11 −11

static void
keypress(XEvent *e) {
	KEYS
	unsigned int len = sizeof key / sizeof key[0];
	unsigned int len = sizeof keys / sizeof keys[0];
	unsigned int i;
	KeySym keysym;
	XKeyEvent *ev = &e->xkey;

	keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
	for(i = 0; i < len; i++)
		if(keysym == key[i].keysym
		&& CLEANMASK(key[i].mod) == CLEANMASK(ev->state))
		if(keysym == keys[i].keysym
		&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state))
		{
			if(key[i].func)
				key[i].func(key[i].arg);
			if(keys[i].func)
				keys[i].func(keys[i].arg);
		}
}


void
grabkeys(void) {
	KEYS
	unsigned int len = sizeof key / sizeof key[0];
	unsigned int len = sizeof keys / sizeof keys[0];
	unsigned int i;
	KeyCode code;

	XUngrabKey(dpy, AnyKey, AnyModifier, root);
	for(i = 0; i < len; i++) {
		code = XKeysymToKeycode(dpy, key[i].keysym);
		XGrabKey(dpy, code, key[i].mod, root, True,
		code = XKeysymToKeycode(dpy, keys[i].keysym);
		XGrabKey(dpy, code, keys[i].mod, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, key[i].mod | LockMask, root, True,
		XGrabKey(dpy, code, keys[i].mod | LockMask, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, key[i].mod | numlockmask, root, True,
		XGrabKey(dpy, code, keys[i].mod | numlockmask, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, key[i].mod | numlockmask | LockMask, root, True,
		XGrabKey(dpy, code, keys[i].mod | numlockmask | LockMask, root, True,
				GrabModeAsync, GrabModeAsync);
	}
}

layout.c +6 −6

initlayouts(void) {
	unsigned int i, w;

	lt = &layout[0];
	nlayouts = sizeof layout / sizeof layout[0];
	lt = &layouts[0];
	nlayouts = sizeof layouts / sizeof layouts[0];
	for(blw = i = 0; i < nlayouts; i++) {
		w = textw(layout[i].symbol);
		w = textw(layouts[i].symbol);
		if(w > blw)
			blw = w;
	}


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

tag.c +6 −6


	if(regs)
		return;
	nrules = sizeof rule / sizeof rule[0];
	nrules = sizeof rules / sizeof rules[0];
	regs = emallocz(nrules * sizeof(Regs));
	for(i = 0; i < nrules; i++) {
		if(rule[i].prop) {
		if(rules[i].prop) {
			reg = emallocz(sizeof(regex_t));
			if(regcomp(reg, rule[i].prop, REG_EXTENDED))
			if(regcomp(reg, rules[i].prop, REG_EXTENDED))
				free(reg);
			else
				regs[i].propregex = reg;
		}
		if(rule[i].tags) {
		if(rules[i].tags) {
			reg = emallocz(sizeof(regex_t));
			if(regcomp(reg, rule[i].tags, REG_EXTENDED))
			if(regcomp(reg, rules[i].tags, REG_EXTENDED))
				free(reg);
			else
				regs[i].tagregex = reg;

				ch.res_name ? ch.res_name : "", c->name);
		for(i = 0; i < nrules; i++)
			if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) {
				c->isfloating = rule[i].isfloating;
				c->isfloating = rules[i].isfloating;
				for(j = 0; regs[i].tagregex && j < ntags; j++) {
					if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) {
						matched = True;

15	15		#define TAGS \
16	16		const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL };
17	17		#define RULES \
18		-	static Rule rule[] = { \
	18	+	static Rule rules[] = { \
19	19		/* class:instance:title regex tags regex isfloating */ \
20	20		{ "Firefox", "3", False }, \
21	21		{ "Gimp", NULL, True }, \

26	26		/* layout(s) */
27	27		#include "tile.h"
28	28		#define LAYOUTS \
29		-	static Layout layout[] = { \
	29	+	static Layout layouts[] = { \
30	30		/* symbol function */ \
31	31		{ "[]=", tile }, /* first entry is default */ \
32	32		{ "><>", floating }, \

37	37		/* key definitions */
38	38		#define MODKEY Mod1Mask
39	39		#define KEYS \
40		-	Key key[] = { \
	40	+	Key keys[] = { \
41	41		/* modifier key function argument */ \
42	42		{ MODKEY, XK_p, spawn, \
43	43		"exe=`dmenu_path \| dmenu -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"'" \

17	17		/* Query class:instance:title for regex matching info with following command:
18	18		* xprop \| awk -F '"' '/^WM_CLASS/ { printf("%s:%s:",$4,$2) }; /^WM_NAME/ { printf("%s\n",$2) }' */
19	19		#define RULES \
20		-	static Rule rule[] = { \
	20	+	static Rule rules[] = { \
21	21		/* class:instance:title regex tags regex isfloating */ \
22	22		{ "Gimp", NULL, True }, \
23	23		{ "MPlayer", NULL, True }, \

27	27		/* layout(s) */
28	28		#include "tile.h"
29	29		#define LAYOUTS \
30		-	static Layout layout[] = { \
	30	+	static Layout layouts[] = { \
31	31		/* symbol function */ \
32	32		{ "[]=", tile }, /* first entry is default */ \
33	33		{ "><>", floating }, \

38	38		/* key definitions */
39	39		#define MODKEY Mod1Mask
40	40		#define KEYS \
41		-	Key key[] = { \
	41	+	Key keys[] = { \
42	42		/* modifier key function argument */ \
43	43		{ MODKEY\|ShiftMask, XK_Return, spawn, "exec xterm" }, \
44	44		{ MODKEY, XK_p, spawn, "exe=`dmenu_path \| dmenu` && exec $exe" }, \

252	252		static void
253	253		keypress(XEvent *e) {
254	254		KEYS
255		-	unsigned int len = sizeof key / sizeof key[0];
	255	+	unsigned int len = sizeof keys / sizeof keys[0];
256	256		unsigned int i;
257	257		KeySym keysym;
258	258		XKeyEvent *ev = &e->xkey;
259	259
260	260		keysym = XKeycodeToKeysym(dpy, (KeyCode)ev->keycode, 0);
261	261		for(i = 0; i < len; i++)
262		-	if(keysym == key[i].keysym
263		-	&& CLEANMASK(key[i].mod) == CLEANMASK(ev->state))
	262	+	if(keysym == keys[i].keysym
	263	+	&& CLEANMASK(keys[i].mod) == CLEANMASK(ev->state))
264	264		{
265		-	if(key[i].func)
266		-	key[i].func(key[i].arg);
	265	+	if(keys[i].func)
	266	+	keys[i].func(keys[i].arg);
267	267		}
268	268		}
269	269

358	358		void
359	359		grabkeys(void) {
360	360		KEYS
361		-	unsigned int len = sizeof key / sizeof key[0];
	361	+	unsigned int len = sizeof keys / sizeof keys[0];
362	362		unsigned int i;
363	363		KeyCode code;
364	364
365	365		XUngrabKey(dpy, AnyKey, AnyModifier, root);
366	366		for(i = 0; i < len; i++) {
367		-	code = XKeysymToKeycode(dpy, key[i].keysym);
368		-	XGrabKey(dpy, code, key[i].mod, root, True,
	367	+	code = XKeysymToKeycode(dpy, keys[i].keysym);
	368	+	XGrabKey(dpy, code, keys[i].mod, root, True,
369	369		GrabModeAsync, GrabModeAsync);
370		-	XGrabKey(dpy, code, key[i].mod \| LockMask, root, True,
	370	+	XGrabKey(dpy, code, keys[i].mod \| LockMask, root, True,
371	371		GrabModeAsync, GrabModeAsync);
372		-	XGrabKey(dpy, code, key[i].mod \| numlockmask, root, True,
	372	+	XGrabKey(dpy, code, keys[i].mod \| numlockmask, root, True,
373	373		GrabModeAsync, GrabModeAsync);
374		-	XGrabKey(dpy, code, key[i].mod \| numlockmask \| LockMask, root, True,
	374	+	XGrabKey(dpy, code, keys[i].mod \| numlockmask \| LockMask, root, True,
375	375		GrabModeAsync, GrabModeAsync);
376	376		}
377	377		}

94	94		initlayouts(void) {
95	95		unsigned int i, w;
96	96
97		-	lt = &layout[0];
98		-	nlayouts = sizeof layout / sizeof layout[0];
	97	+	lt = &layouts[0];
	98	+	nlayouts = sizeof layouts / sizeof layouts[0];
99	99		for(blw = i = 0; i < nlayouts; i++) {
100		-	w = textw(layout[i].symbol);
	100	+	w = textw(layouts[i].symbol);
101	101		if(w > blw)
102	102		blw = w;
103	103		}

144	144
145	145		if(!arg) {
146	146		lt++;
147		-	if(lt == layout + nlayouts)
148		-	lt = layout;
	147	+	if(lt == layouts + nlayouts)
	148	+	lt = layouts;
149	149		}
150	150		else {
151	151		i = atoi(arg);
152	152		if(i < 0 \|\| i >= nlayouts)
153	153		return;
154		-	lt = &layout[i];
	154	+	lt = &layouts[i];
155	155		}
156	156		if(sel)
157	157		arrange();

59	59
60	60		if(regs)
61	61		return;
62		-	nrules = sizeof rule / sizeof rule[0];
	62	+	nrules = sizeof rules / sizeof rules[0];
63	63		regs = emallocz(nrules * sizeof(Regs));
64	64		for(i = 0; i < nrules; i++) {
65		-	if(rule[i].prop) {
	65	+	if(rules[i].prop) {
66	66		reg = emallocz(sizeof(regex_t));
67		-	if(regcomp(reg, rule[i].prop, REG_EXTENDED))
	67	+	if(regcomp(reg, rules[i].prop, REG_EXTENDED))
68	68		free(reg);
69	69		else
70	70		regs[i].propregex = reg;
71	71		}
72		-	if(rule[i].tags) {
	72	+	if(rules[i].tags) {
73	73		reg = emallocz(sizeof(regex_t));
74		-	if(regcomp(reg, rule[i].tags, REG_EXTENDED))
	74	+	if(regcomp(reg, rules[i].tags, REG_EXTENDED))
75	75		free(reg);
76	76		else
77	77		regs[i].tagregex = reg;

124	124		ch.res_name ? ch.res_name : "", c->name);
125	125		for(i = 0; i < nrules; i++)
126	126		if(regs[i].propregex && !regexec(regs[i].propregex, prop, 1, &tmp, 0)) {
127		-	c->isfloating = rule[i].isfloating;
	127	+	c->isfloating = rules[i].isfloating;
128	128		for(j = 0; regs[i].tagregex && j < ntags; j++) {
129	129		if(!regexec(regs[i].tagregex, tags[j], 1, &tmp, 0)) {
130	130		matched = True;