git.stevedylan.dev

made status bar drawing more robust, implemented togglemax and togglemode, works quite well 4688ad18

arg@10ksloc.org · 2006-07-20 15:07 5 file(s) · +59 −33

client.c +38 −15

	if(!sel)
		return;

	if(sel->ismax)
		togglemax(NULL);

	if(!(c = getnext(sel->next, tsel)))
		c = getnext(clients, tsel);
	if(c) {


	if(!sel)
		return;

	if(sel->ismax)
		togglemax(NULL);

	if((c = sel->revert && sel->revert->tags[tsel] ? sel->revert : NULL)) {
		higher(c);

	c->next = clients;
	clients = c;

	XGrabButton(dpy, Button1, ControlMask, c->win, False, ButtonPressMask,
			GrabModeAsync, GrabModeSync, None, None);
	XGrabButton(dpy, Button1, MODKEY, c->win, False, ButtonPressMask,
			GrabModeAsync, GrabModeSync, None, None);
	XGrabButton(dpy, Button2, MODKEY, c->win, False, ButtonPressMask,

}

void
maximize(Arg *arg)
{
	if(!sel)
		return;
	sel->x = sx;
	sel->y = sy + bh;
	sel->w = sw - 2 * sel->border;
	sel->h = sh - 2 * sel->border - bh;
	higher(sel);
	resize(sel, False, TopLeft);
}

void
pop(Client *c)
{
	Client **l;

	}
	XFree(name.value);
	resizetitle(c);
}

void
togglemax(Arg *arg)
{
	int ox, oy, ow, oh;
	XEvent ev;

	if(!sel)
		return;

	if((sel->ismax = !sel->ismax)) {
		ox = sel->x;
		oy = sel->y;
		ow = sel->w;
		oh = sel->h;
		sel->x = sx;
		sel->y = sy + bh;
		sel->w = sw - 2 * sel->border;
		sel->h = sh - 2 * sel->border - bh;

		higher(sel);
		resize(sel, False, TopLeft);

		sel->x = ox;
		sel->y = oy;
		sel->w = ow;
		sel->h = oh;
	}
	else
		resize(sel, False, TopLeft);
	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
}

void

draw.c +6 −7

void
drawstatus()
{
	int i;
	int i, x;
	Bool istile = arrange == dotile;

	dc.x = dc.y = 0;

		else
			drawtext(tags[i], (i != tsel), True);
	}
	if(sel) {
		dc.x += dc.w;
		dc.w = textw(sel->name);
		drawtext(sel->name, istile, True);
	}
	x = dc.x + dc.w;
	dc.w = textw(stext);
	dc.x = bx + bw - dc.w;
	drawtext(stext, !istile, False);

	if(sel && ((dc.w = dc.x - x) >= bh)) {
		dc.x = x;
		drawtext(sel->name, istile, True);
	}
	XCopyArea(dpy, dc.drawable, barwin, dc.gc, 0, 0, bw, bh, 0, 0);
	XSync(dpy, False);
}

dwm.h +3 −1

	unsigned int border;
	long flags; 
	Bool isfloat;
	Bool ismax;
	Client *next;
	Client *revert;
	Window win;

extern void killclient(Arg *arg);
extern void lower(Client *c);
extern void manage(Window w, XWindowAttributes *wa);
extern void maximize(Arg *arg);
extern void pop(Client *c);
extern void resize(Client *c, Bool inc, Corner sticky);
extern void setsize(Client *c);
extern void settitle(Client *c);
extern void togglemax(Arg *arg);
extern void unmanage(Client *c);
extern void zoom(Arg *arg);


extern void heretag(Arg *arg);
extern void replacetag(Arg *arg);
extern void settags(Client *c);
extern void togglemode(Arg *arg);
extern void view(Arg *arg);

/* util.c */

event.c +3 −8

	{ MODKEY,		XK_3,		view,		{ .i = Twork } }, 
	{ MODKEY,		XK_j,		focusnext,	{ 0 } }, 
	{ MODKEY,		XK_k,		focusprev,	{ 0 } },
	{ MODKEY,		XK_m,		maximize,	{ 0 } }, 
	{ MODKEY,		XK_space,	dotile,		{ 0 } }, 
	{ MODKEY,		XK_m,		togglemax,	{ 0 } }, 
	{ MODKEY,		XK_space,	togglemode,	{ 0 } }, 
	{ MODKEY,		XK_Return,	zoom,		{ 0 } },
	{ ControlMask|ShiftMask,XK_0,		heretag,	{ .i = Tscratch } }, 
	{ ControlMask|ShiftMask,XK_1,		heretag,	{ .i = Tdev } }, 

	{ MODKEY|ShiftMask,	XK_g,		spawn,		{ .argv = gimp } },
	{ MODKEY|ShiftMask,	XK_l,		spawn,		{ .argv = xlock } },
	{ MODKEY|ShiftMask,	XK_q,		quit,		{ 0 } },
	{ MODKEY|ShiftMask,	XK_space,	dofloat,	{ 0 } }, 
	{ MODKEY|ShiftMask,	XK_w,		spawn,		{ .argv = browse } },
	{ MODKEY|ShiftMask,	XK_Return,	spawn,		{ .argv = term } },
};

		default:
			break;
		case Button1:
			if(arrange == dotile && !c->isfloat) {
				if((ev->state & ControlMask) && (ev->button == Button1))
					zoom(NULL);
			}
			else {
			if(arrange == dofloat || c->isfloat) {
				higher(c);
				movemouse(c);
			}

tag.c +9 −2

{
	Client *c;

	arrange = dofloat;
	for(c = clients; c; c = c->next) {
		c->ismax = False;
		if(c->tags[tsel]) {
			resize(c, True, TopLeft);
		}

	Client *c;

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

		h = sh - bh;

	for(i = 0, c = clients; c; c = c->next) {
		c->ismax = False;
		if(c->tags[tsel]) {
			if(c->isfloat) {
				higher(c);

	}
	if(!matched)
		c->tags[tsel] = tags[tsel];
}

void
togglemode(Arg *arg)
{
	arrange = arrange == dofloat ? dotile : dofloat;
	arrange(NULL);
}

void

70	70		if(!sel)
71	71		return;
72	72
	73	+	if(sel->ismax)
	74	+	togglemax(NULL);
	75	+
73	76		if(!(c = getnext(sel->next, tsel)))
74	77		c = getnext(clients, tsel);
75	78		if(c) {

86	89
87	90		if(!sel)
88	91		return;
	92	+
	93	+	if(sel->ismax)
	94	+	togglemax(NULL);
89	95
90	96		if((c = sel->revert && sel->revert->tags[tsel] ? sel->revert : NULL)) {
91	97		higher(c);

234	240		c->next = clients;
235	241		clients = c;
236	242
237		-	XGrabButton(dpy, Button1, ControlMask, c->win, False, ButtonPressMask,
238		-	GrabModeAsync, GrabModeSync, None, None);
239	243		XGrabButton(dpy, Button1, MODKEY, c->win, False, ButtonPressMask,
240	244		GrabModeAsync, GrabModeSync, None, None);
241	245		XGrabButton(dpy, Button2, MODKEY, c->win, False, ButtonPressMask,

264	268		}
265	269
266	270		void
267		-	maximize(Arg *arg)
268		-	{
269		-	if(!sel)
270		-	return;
271		-	sel->x = sx;
272		-	sel->y = sy + bh;
273		-	sel->w = sw - 2 * sel->border;
274		-	sel->h = sh - 2 * sel->border - bh;
275		-	higher(sel);
276		-	resize(sel, False, TopLeft);
277		-	}
278		-
279		-	void
280	271		pop(Client *c)
281	272		{
282	273		Client **l;

402	393		}
403	394		XFree(name.value);
404	395		resizetitle(c);
	396	+	}
	397	+
	398	+	void
	399	+	togglemax(Arg *arg)
	400	+	{
	401	+	int ox, oy, ow, oh;
	402	+	XEvent ev;
	403	+
	404	+	if(!sel)
	405	+	return;
	406	+
	407	+	if((sel->ismax = !sel->ismax)) {
	408	+	ox = sel->x;
	409	+	oy = sel->y;
	410	+	ow = sel->w;
	411	+	oh = sel->h;
	412	+	sel->x = sx;
	413	+	sel->y = sy + bh;
	414	+	sel->w = sw - 2 * sel->border;
	415	+	sel->h = sh - 2 * sel->border - bh;
	416	+
	417	+	higher(sel);
	418	+	resize(sel, False, TopLeft);
	419	+
	420	+	sel->x = ox;
	421	+	sel->y = oy;
	422	+	sel->w = ow;
	423	+	sel->h = oh;
	424	+	}
	425	+	else
	426	+	resize(sel, False, TopLeft);
	427	+	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
405	428		}
406	429
407	430		void

107	107		void
108	108		drawstatus()
109	109		{
110		-	int i;
	110	+	int i, x;
111	111		Bool istile = arrange == dotile;
112	112
113	113		dc.x = dc.y = 0;

123	123		else
124	124		drawtext(tags[i], (i != tsel), True);
125	125		}
126		-	if(sel) {
127		-	dc.x += dc.w;
128		-	dc.w = textw(sel->name);
129		-	drawtext(sel->name, istile, True);
130		-	}
	126	+	x = dc.x + dc.w;
131	127		dc.w = textw(stext);
132	128		dc.x = bx + bw - dc.w;
133	129		drawtext(stext, !istile, False);
134		-
	130	+	if(sel && ((dc.w = dc.x - x) >= bh)) {
	131	+	dc.x = x;
	132	+	drawtext(sel->name, istile, True);
	133	+	}
135	134		XCopyArea(dpy, dc.drawable, barwin, dc.gc, 0, 0, bw, bh, 0, 0);
136	135		XSync(dpy, False);
137	136		}

74	74		unsigned int border;
75	75		long flags;
76	76		Bool isfloat;
	77	+	Bool ismax;
77	78		Client *next;
78	79		Client *revert;
79	80		Window win;

104	105		extern void killclient(Arg *arg);
105	106		extern void lower(Client *c);
106	107		extern void manage(Window w, XWindowAttributes *wa);
107		-	extern void maximize(Arg *arg);
108	108		extern void pop(Client *c);
109	109		extern void resize(Client *c, Bool inc, Corner sticky);
110	110		extern void setsize(Client *c);
111	111		extern void settitle(Client *c);
	112	+	extern void togglemax(Arg *arg);
112	113		extern void unmanage(Client *c);
113	114		extern void zoom(Arg *arg);
114	115

137	138		extern void heretag(Arg *arg);
138	139		extern void replacetag(Arg *arg);
139	140		extern void settags(Client *c);
	141	+	extern void togglemode(Arg *arg);
140	142		extern void view(Arg *arg);
141	143
142	144		/* util.c */

40	40		{ MODKEY, XK_3, view, { .i = Twork } },
41	41		{ MODKEY, XK_j, focusnext, { 0 } },
42	42		{ MODKEY, XK_k, focusprev, { 0 } },
43		-	{ MODKEY, XK_m, maximize, { 0 } },
44		-	{ MODKEY, XK_space, dotile, { 0 } },
	43	+	{ MODKEY, XK_m, togglemax, { 0 } },
	44	+	{ MODKEY, XK_space, togglemode, { 0 } },
45	45		{ MODKEY, XK_Return, zoom, { 0 } },
46	46		{ ControlMask\|ShiftMask,XK_0, heretag, { .i = Tscratch } },
47	47		{ ControlMask\|ShiftMask,XK_1, heretag, { .i = Tdev } },

55	55		{ MODKEY\|ShiftMask, XK_g, spawn, { .argv = gimp } },
56	56		{ MODKEY\|ShiftMask, XK_l, spawn, { .argv = xlock } },
57	57		{ MODKEY\|ShiftMask, XK_q, quit, { 0 } },
58		-	{ MODKEY\|ShiftMask, XK_space, dofloat, { 0 } },
59	58		{ MODKEY\|ShiftMask, XK_w, spawn, { .argv = browse } },
60	59		{ MODKEY\|ShiftMask, XK_Return, spawn, { .argv = term } },
61	60		};

170	169		default:
171	170		break;
172	171		case Button1:
173		-	if(arrange == dotile && !c->isfloat) {
174		-	if((ev->state & ControlMask) && (ev->button == Button1))
175		-	zoom(NULL);
176		-	}
177		-	else {
	172	+	if(arrange == dofloat \|\| c->isfloat) {
178	173		higher(c);
179	174		movemouse(c);
180	175		}

51	51		{
52	52		Client *c;
53	53
54		-	arrange = dofloat;
55	54		for(c = clients; c; c = c->next) {
	55	+	c->ismax = False;
56	56		if(c->tags[tsel]) {
57	57		resize(c, True, TopLeft);
58	58		}

75	75		Client *c;
76	76
77	77		w = sw - mw;
78		-	arrange = dotile;
79	78		for(n = 0, c = clients; c; c = c->next)
80	79		if(c->tags[tsel] && !c->isfloat)
81	80		n++;

86	85		h = sh - bh;
87	86
88	87		for(i = 0, c = clients; c; c = c->next) {
	88	+	c->ismax = False;
89	89		if(c->tags[tsel]) {
90	90		if(c->isfloat) {
91	91		higher(c);

210	210		}
211	211		if(!matched)
212	212		c->tags[tsel] = tags[tsel];
	213	+	}
	214	+
	215	+	void
	216	+	togglemode(Arg *arg)
	217	+	{
	218	+	arrange = arrange == dofloat ? dotile : dofloat;
	219	+	arrange(NULL);
213	220		}
214	221
215	222		void