git.stevedylan.dev

added mini stuff 66da1532

Anselm R. Garbe · 2006-07-13 21:42 4 file(s) · +69 −46

client.c +31 −20


#include "dwm.h"

static void (*arrange)(Arg *) = tiling;
void (*arrange)(Arg *) = tiling;

static Rule rule[] = {
	{ "Firefox-bin", "Gecko", { [Twww] = "www" } },
	/* class			instance	tags						floating */
	{ "Firefox-bin",	"Gecko",	{ [Twww] = "www" },			False },
};

static Client *

}

void
tag(Arg *arg)
tappend(Arg *arg)
{
	int i, n;
	if(!sel)
		return;

	if(arg->i == tsel) {
		for(n = i = 0; i < TLast; i++)
			if(sel->tags[i])
				n++;
		if(n < 2)
			return;
	}

	if(sel->tags[arg->i])
		sel->tags[arg->i] = NULL; /* toggle tag */
	else
		sel->tags[arg->i] = tags[arg->i];
	sel->tags[arg->i] = tags[arg->i];
	arrange(NULL);
}

void
ttrunc(Arg *arg)
{
	int i;
	if(!sel)
		return;

	for(i = 0; i < TLast; i++)
		sel->tags[i] = NULL;
	tappend(arg);
}

static void

	w = sw - mw;
	arrange = tiling;
	for(n = 0, c = clients; c; c = c->next)
		if(c->tags[tsel])
		if(c->tags[tsel] && !c->floating)
			n++;

	h = (n > 1) ? sh / (n - 1) : sh;

	for(i = 0, c = clients; c; c = c->next) {
		if(c->tags[tsel]) {
			if(c->floating) {
				craise(c);
				resize(c, True);
				continue;
			}
			if(n == 1) {
				c->x = sx;
				c->y = sy;


	if(XGetClassHint(dpy, c->win, &ch)) {
		if(ch.res_class && ch.res_name) {
			fprintf(stderr, "%s:%s\n", ch.res_class, ch.res_name);
			for(i = 0; i < len; i++)
				if(!strncmp(rule[i].class, ch.res_class, sizeof(rule[i].class))
					&& !strncmp(rule[i].instance, ch.res_name, sizeof(rule[i].instance)))
				{
			fprintf(stderr, "->>>%s:%s\n", ch.res_class, ch.res_name);
					for(j = 0; j < TLast; j++)
						c->tags[j] = rule[i].tags[j];
					c->floating = rule[i].floating;
					matched = True;
					break;
				}

{
	Client *c, **l;
	XSetWindowAttributes twa;
	Window trans;

	c = emallocz(sizeof(Client));
	c->win = w;

	update_size(c);
	XSelectInput(dpy, c->win,
			StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
	XGetTransientForHint(dpy, c->win, &c->trans);
	XGetTransientForHint(dpy, c->win, &trans);
	twa.override_redirect = 1;
	twa.background_pixmap = ParentRelative;
	twa.event_mask = ExposureMask;

			GrabModeAsync, GrabModeSync, None, None);
	XGrabButton(dpy, Button3, Mod1Mask, c->win, False, ButtonPressMask,
			GrabModeAsync, GrabModeSync, None, None);

	if(!c->floating)
		c->floating = trans
			|| ((c->maxw == c->minw) && (c->maxh == c->minh));

	arrange(NULL);
	if(c->tags[tsel])
		focus(c);

dev.c +27 −21

const char *xlock[] = { "xlock", NULL };

static Key key[] = {
	{ Mod1Mask, XK_Return, spawn, { .argv = term } },
	{ Mod1Mask, XK_w, spawn, { .argv = browse } },
	{ Mod1Mask, XK_l, spawn, { .argv = xlock } },
	{ Mod1Mask, XK_k, prevc, { 0 } },
	{ Mod1Mask, XK_j, nextc, { 0 } }, 
	{ Mod1Mask, XK_m, max, { 0 } }, 
	{ Mod1Mask, XK_0, view, { .i = Tscratch } }, 
	{ Mod1Mask, XK_1, view, { .i = Tdev } }, 
	{ Mod1Mask, XK_2, view, { .i = Tirc } }, 
	{ Mod1Mask, XK_3, view, { .i = Twww } }, 
	{ Mod1Mask, XK_4, view, { .i = Twork } }, 
	{ Mod1Mask, XK_space, tiling, { 0 } }, 
	{ Mod1Mask | ShiftMask, XK_Return, zoom, { 0 } },
	{ Mod1Mask | ShiftMask, XK_space, floating, { 0 } }, 
	{ Mod1Mask | ShiftMask, XK_0, tag, { .i = Tscratch } }, 
	{ Mod1Mask | ShiftMask, XK_1, tag, { .i = Tdev } }, 
	{ Mod1Mask | ShiftMask, XK_2, tag, { .i = Tirc } }, 
	{ Mod1Mask | ShiftMask, XK_3, tag, { .i = Twww } }, 
	{ Mod1Mask | ShiftMask, XK_4, tag, { .i = Twork } }, 
	{ Mod1Mask | ShiftMask, XK_c, ckill, { 0 } }, 
	{ Mod1Mask | ShiftMask, XK_q, quit, { 0 } },
	/* modifier				key			function	arguments */
	{ Mod1Mask,				XK_Return,	zoom,		{ 0 } },
	{ Mod1Mask,				XK_k,		prevc,		{ 0 } },
	{ Mod1Mask,				XK_j,		nextc,		{ 0 } }, 
	{ Mod1Mask,				XK_m,		max,		{ 0 } }, 
	{ Mod1Mask,				XK_0,		view,		{ .i = Tscratch } }, 
	{ Mod1Mask,				XK_1,		view,		{ .i = Tdev } }, 
	{ Mod1Mask,				XK_2,		view,		{ .i = Tirc } }, 
	{ Mod1Mask,				XK_3,		view,		{ .i = Twww } }, 
	{ Mod1Mask,				XK_4,		view,		{ .i = Twork } }, 
	{ Mod1Mask,				XK_space,	tiling,		{ 0 } }, 
	{ Mod1Mask|ShiftMask,	XK_space,	floating,	{ 0 } }, 
	{ Mod1Mask|ShiftMask,	XK_0,		ttrunc,		{ .i = Tscratch } }, 
	{ Mod1Mask|ShiftMask,	XK_1,		ttrunc,		{ .i = Tdev } }, 
	{ Mod1Mask|ShiftMask,	XK_2,		ttrunc,		{ .i = Tirc } }, 
	{ Mod1Mask|ShiftMask,	XK_3,		ttrunc,		{ .i = Twww } }, 
	{ Mod1Mask|ShiftMask,	XK_4,		ttrunc,		{ .i = Twork } }, 
	{ Mod1Mask|ShiftMask,	XK_c,		ckill,		{ 0 } }, 
	{ Mod1Mask|ShiftMask,	XK_q,		quit,		{ 0 } },
	{ Mod1Mask|ShiftMask,	XK_Return,	spawn,		{ .argv = term } },
	{ Mod1Mask|ShiftMask,	XK_w,		spawn,		{ .argv = browse } },
	{ Mod1Mask|ShiftMask,	XK_l,		spawn,		{ .argv = xlock } },
	{ ControlMask,			XK_0,		tappend,	{ .i = Tscratch } }, 
	{ ControlMask,			XK_1,		tappend,	{ .i = Tdev } }, 
	{ ControlMask,			XK_2,		tappend,	{ .i = Tirc } }, 
	{ ControlMask,			XK_3,		tappend,	{ .i = Twww } }, 
	{ ControlMask,			XK_4,		tappend,	{ .i = Twork } }, 
};

/********** CUSTOMIZE **********/

dwm.h +6 −3

	int grav;
	unsigned int border;
	long flags; 
	Bool floating;
	Window win;
	Window trans;
	Window title;
	Client *next;
	Client *revert;

	const char *class;
	const char *instance;
	char *tags[TLast];
	Bool floating;
};

struct Key {

extern Atom wm_atom[WMLast], net_atom[NetLast];
extern Cursor cursor[CurLast];
extern Bool running, issel;
extern void (*handler[LASTEvent]) (XEvent *);
extern void (*handler[LASTEvent])(XEvent *);
extern void (*arrange)(Arg *);

extern int tsel, screen, sx, sy, sw, sh, mw, th;
extern char *tags[TLast];

extern void max(Arg *arg);
extern void floating(Arg *arg);
extern void tiling(Arg *arg);
extern void tag(Arg *arg);
extern void ttrunc(Arg *arg);
extern void tappend(Arg *arg);
extern void view(Arg *arg);
extern void zoom(Arg *arg);
extern void gravitate(Client *c, Bool invert);

event.c +5 −2

		if(ev->value_mask & CWBorderWidth)
			c->border = ev->border_width;
		gravitate(c, False);
		resize(c, True);
	}

	wc.x = ev->x;

propertynotify(XEvent *e)
{
	XPropertyEvent *ev = &e->xproperty;
	Window trans;
	Client *c;

	if(ev->state == PropertyDelete)

		switch (ev->atom) {
			default: break;
			case XA_WM_TRANSIENT_FOR:
				XGetTransientForHint(dpy, c->win, &c->trans);
				XGetTransientForHint(dpy, c->win, &trans);
				if(!c->floating && (c->floating = (trans != 0)))
					arrange(NULL);
				break;
				update_size(c);
			case XA_WM_NORMAL_HINTS:
				update_size(c);
				break;

11	11
12	12		#include "dwm.h"
13	13
14		-	static void (arrange)(Arg ) = tiling;
	14	+	void (arrange)(Arg ) = tiling;
15	15
16	16		static Rule rule[] = {
17		-	{ "Firefox-bin", "Gecko", { [Twww] = "www" } },
	17	+	/* class instance tags floating */
	18	+	{ "Firefox-bin", "Gecko", { [Twww] = "www" }, False },
18	19		};
19	20
20	21		static Client *

64	65		}
65	66
66	67		void
67		-	tag(Arg *arg)
	68	+	tappend(Arg *arg)
68	69		{
69		-	int i, n;
70	70		if(!sel)
71	71		return;
72	72
73		-	if(arg->i == tsel) {
74		-	for(n = i = 0; i < TLast; i++)
75		-	if(sel->tags[i])
76		-	n++;
77		-	if(n < 2)
78		-	return;
79		-	}
80		-
81		-	if(sel->tags[arg->i])
82		-	sel->tags[arg->i] = NULL; /* toggle tag */
83		-	else
84		-	sel->tags[arg->i] = tags[arg->i];
	73	+	sel->tags[arg->i] = tags[arg->i];
85	74		arrange(NULL);
	75	+	}
	76	+
	77	+	void
	78	+	ttrunc(Arg *arg)
	79	+	{
	80	+	int i;
	81	+	if(!sel)
	82	+	return;
	83	+
	84	+	for(i = 0; i < TLast; i++)
	85	+	sel->tags[i] = NULL;
	86	+	tappend(arg);
86	87		}
87	88
88	89		static void

122	123		w = sw - mw;
123	124		arrange = tiling;
124	125		for(n = 0, c = clients; c; c = c->next)
125		-	if(c->tags[tsel])
	126	+	if(c->tags[tsel] && !c->floating)
126	127		n++;
127	128
128	129		h = (n > 1) ? sh / (n - 1) : sh;
129	130
130	131		for(i = 0, c = clients; c; c = c->next) {
131	132		if(c->tags[tsel]) {
	133	+	if(c->floating) {
	134	+	craise(c);
	135	+	resize(c, True);
	136	+	continue;
	137	+	}
132	138		if(n == 1) {
133	139		c->x = sx;
134	140		c->y = sy;

330	336
331	337		if(XGetClassHint(dpy, c->win, &ch)) {
332	338		if(ch.res_class && ch.res_name) {
333		-	fprintf(stderr, "%s:%s\n", ch.res_class, ch.res_name);
334	339		for(i = 0; i < len; i++)
335	340		if(!strncmp(rule[i].class, ch.res_class, sizeof(rule[i].class))
336	341		&& !strncmp(rule[i].instance, ch.res_name, sizeof(rule[i].instance)))
337	342		{
338		-	fprintf(stderr, "->>>%s:%s\n", ch.res_class, ch.res_name);
339	343		for(j = 0; j < TLast; j++)
340	344		c->tags[j] = rule[i].tags[j];
	345	+	c->floating = rule[i].floating;
341	346		matched = True;
342	347		break;
343	348		}

357	362		{
358	363		Client c, *l;
359	364		XSetWindowAttributes twa;
	365	+	Window trans;
360	366
361	367		c = emallocz(sizeof(Client));
362	368		c->win = w;

370	376		update_size(c);
371	377		XSelectInput(dpy, c->win,
372	378		StructureNotifyMask \| PropertyChangeMask \| EnterWindowMask);
373		-	XGetTransientForHint(dpy, c->win, &c->trans);
	379	+	XGetTransientForHint(dpy, c->win, &trans);
374	380		twa.override_redirect = 1;
375	381		twa.background_pixmap = ParentRelative;
376	382		twa.event_mask = ExposureMask;

396	402		GrabModeAsync, GrabModeSync, None, None);
397	403		XGrabButton(dpy, Button3, Mod1Mask, c->win, False, ButtonPressMask,
398	404		GrabModeAsync, GrabModeSync, None, None);
	405	+
	406	+	if(!c->floating)
	407	+	c->floating = trans
	408	+	\|\| ((c->maxw == c->minw) && (c->maxh == c->minh));
	409	+
399	410		arrange(NULL);
400	411		if(c->tags[tsel])
401	412		focus(c);

66	66		int grav;
67	67		unsigned int border;
68	68		long flags;
	69	+	Bool floating;
69	70		Window win;
70		-	Window trans;
71	71		Window title;
72	72		Client *next;
73	73		Client *revert;

77	77		const char *class;
78	78		const char *instance;
79	79		char *tags[TLast];
	80	+	Bool floating;
80	81		};
81	82
82	83		struct Key {

91	92		extern Atom wm_atom[WMLast], net_atom[NetLast];
92	93		extern Cursor cursor[CurLast];
93	94		extern Bool running, issel;
94		-	extern void (handler[LASTEvent]) (XEvent );
	95	+	extern void (handler[LASTEvent])(XEvent );
	96	+	extern void (arrange)(Arg );
95	97
96	98		extern int tsel, screen, sx, sy, sw, sh, mw, th;
97	99		extern char *tags[TLast];

117	119		extern void max(Arg *arg);
118	120		extern void floating(Arg *arg);
119	121		extern void tiling(Arg *arg);
120		-	extern void tag(Arg *arg);
	122	+	extern void ttrunc(Arg *arg);
	123	+	extern void tappend(Arg *arg);
121	124		extern void view(Arg *arg);
122	125		extern void zoom(Arg *arg);
123	126		extern void gravitate(Client *c, Bool invert);

89	89		if(ev->value_mask & CWBorderWidth)
90	90		c->border = ev->border_width;
91	91		gravitate(c, False);
	92	+	resize(c, True);
92	93		}
93	94
94	95		wc.x = ev->x;

179	180		propertynotify(XEvent *e)
180	181		{
181	182		XPropertyEvent *ev = &e->xproperty;
	183	+	Window trans;
182	184		Client *c;
183	185
184	186		if(ev->state == PropertyDelete)

192	194		switch (ev->atom) {
193	195		default: break;
194	196		case XA_WM_TRANSIENT_FOR:
195		-	XGetTransientForHint(dpy, c->win, &c->trans);
	197	+	XGetTransientForHint(dpy, c->win, &trans);
	198	+	if(!c->floating && (c->floating = (trans != 0)))
	199	+	arrange(NULL);
196	200		break;
197		-	update_size(c);
198	201		case XA_WM_NORMAL_HINTS:
199	202		update_size(c);
200	203		break;

20	20		const char *xlock[] = { "xlock", NULL };
21	21
22	22		static Key key[] = {
23		-	{ Mod1Mask, XK_Return, spawn, { .argv = term } },
24		-	{ Mod1Mask, XK_w, spawn, { .argv = browse } },
25		-	{ Mod1Mask, XK_l, spawn, { .argv = xlock } },
26		-	{ Mod1Mask, XK_k, prevc, { 0 } },
27		-	{ Mod1Mask, XK_j, nextc, { 0 } },
28		-	{ Mod1Mask, XK_m, max, { 0 } },
29		-	{ Mod1Mask, XK_0, view, { .i = Tscratch } },
30		-	{ Mod1Mask, XK_1, view, { .i = Tdev } },
31		-	{ Mod1Mask, XK_2, view, { .i = Tirc } },
32		-	{ Mod1Mask, XK_3, view, { .i = Twww } },
33		-	{ Mod1Mask, XK_4, view, { .i = Twork } },
34		-	{ Mod1Mask, XK_space, tiling, { 0 } },
35		-	{ Mod1Mask \| ShiftMask, XK_Return, zoom, { 0 } },
36		-	{ Mod1Mask \| ShiftMask, XK_space, floating, { 0 } },
37		-	{ Mod1Mask \| ShiftMask, XK_0, tag, { .i = Tscratch } },
38		-	{ Mod1Mask \| ShiftMask, XK_1, tag, { .i = Tdev } },
39		-	{ Mod1Mask \| ShiftMask, XK_2, tag, { .i = Tirc } },
40		-	{ Mod1Mask \| ShiftMask, XK_3, tag, { .i = Twww } },
41		-	{ Mod1Mask \| ShiftMask, XK_4, tag, { .i = Twork } },
42		-	{ Mod1Mask \| ShiftMask, XK_c, ckill, { 0 } },
43		-	{ Mod1Mask \| ShiftMask, XK_q, quit, { 0 } },
	23	+	/* modifier key function arguments */
	24	+	{ Mod1Mask, XK_Return, zoom, { 0 } },
	25	+	{ Mod1Mask, XK_k, prevc, { 0 } },
	26	+	{ Mod1Mask, XK_j, nextc, { 0 } },
	27	+	{ Mod1Mask, XK_m, max, { 0 } },
	28	+	{ Mod1Mask, XK_0, view, { .i = Tscratch } },
	29	+	{ Mod1Mask, XK_1, view, { .i = Tdev } },
	30	+	{ Mod1Mask, XK_2, view, { .i = Tirc } },
	31	+	{ Mod1Mask, XK_3, view, { .i = Twww } },
	32	+	{ Mod1Mask, XK_4, view, { .i = Twork } },
	33	+	{ Mod1Mask, XK_space, tiling, { 0 } },
	34	+	{ Mod1Mask\|ShiftMask, XK_space, floating, { 0 } },
	35	+	{ Mod1Mask\|ShiftMask, XK_0, ttrunc, { .i = Tscratch } },
	36	+	{ Mod1Mask\|ShiftMask, XK_1, ttrunc, { .i = Tdev } },
	37	+	{ Mod1Mask\|ShiftMask, XK_2, ttrunc, { .i = Tirc } },
	38	+	{ Mod1Mask\|ShiftMask, XK_3, ttrunc, { .i = Twww } },
	39	+	{ Mod1Mask\|ShiftMask, XK_4, ttrunc, { .i = Twork } },
	40	+	{ Mod1Mask\|ShiftMask, XK_c, ckill, { 0 } },
	41	+	{ Mod1Mask\|ShiftMask, XK_q, quit, { 0 } },
	42	+	{ Mod1Mask\|ShiftMask, XK_Return, spawn, { .argv = term } },
	43	+	{ Mod1Mask\|ShiftMask, XK_w, spawn, { .argv = browse } },
	44	+	{ Mod1Mask\|ShiftMask, XK_l, spawn, { .argv = xlock } },
	45	+	{ ControlMask, XK_0, tappend, { .i = Tscratch } },
	46	+	{ ControlMask, XK_1, tappend, { .i = Tdev } },
	47	+	{ ControlMask, XK_2, tappend, { .i = Tirc } },
	48	+	{ ControlMask, XK_3, tappend, { .i = Twww } },
	49	+	{ ControlMask, XK_4, tappend, { .i = Twork } },
44	50		};
45	51
46	52		/******** CUSTOMIZE ********/