git.stevedylan.dev

applied yiyus domax patch with slight modifications 0fe2e783

Anselm R Garbe · 2008-05-26 09:39 3 file(s) · +55 −76

config.def.h +16 −36


/* key definitions */
#define MODKEY Mod1Mask
#define TAGKEYS(KEY,TAG) \
        { MODKEY,                       KEY,      view,           TAG }, \
        { MODKEY|ControlMask,           KEY,      toggleview,     TAG }, \
        { MODKEY|ShiftMask,             KEY,      tag,            TAG }, \
        { MODKEY|ControlMask|ShiftMask, KEY,      toggletag,      TAG },

Key keys[] = {
	/* modifier                     key        function        argument */
	{ MODKEY,                       XK_p,      spawn,          (char *)"exec dmenu_run -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' -sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"'" },

	{ MODKEY,                       XK_k,      focusprev,      NULL },
	{ MODKEY,                       XK_h,      setmfact,       (double[]){-0.05} },
	{ MODKEY,                       XK_l,      setmfact,       (double[]){+0.05} },
	{ MODKEY,                       XK_m,      togglemax,      NULL },
	{ MODKEY,                       XK_Return, zoom,           NULL },
	{ MODKEY,                       XK_Tab,    viewprevtag,    NULL },
	{ MODKEY|ShiftMask,             XK_c,      killclient,     NULL },
	{ MODKEY,                       XK_space,  togglelayout,   NULL },
	{ MODKEY|ShiftMask,             XK_space,  togglefloating, NULL },
	{ MODKEY,                       XK_0,      view,           (uint[]){ ~0 } },
	{ MODKEY,                       XK_1,      view,           (uint[]){ 1 << 0 } },
	{ MODKEY,                       XK_2,      view,           (uint[]){ 1 << 1 } },
	{ MODKEY,                       XK_3,      view,           (uint[]){ 1 << 2 } },
	{ MODKEY,                       XK_4,      view,           (uint[]){ 1 << 3 } },
	{ MODKEY,                       XK_5,      view,           (uint[]){ 1 << 4 } },
	{ MODKEY,                       XK_6,      view,           (uint[]){ 1 << 5 } },
	{ MODKEY,                       XK_7,      view,           (uint[]){ 1 << 6 } },
	{ MODKEY,                       XK_8,      view,           (uint[]){ 1 << 7 } },
	{ MODKEY,                       XK_9,      view,           (uint[]){ 1 << 8 } },
	{ MODKEY|ControlMask,           XK_1,      toggleview,     (uint[]){ 1 << 0 } },
	{ MODKEY|ControlMask,           XK_2,      toggleview,     (uint[]){ 1 << 1 } },
	{ MODKEY|ControlMask,           XK_3,      toggleview,     (uint[]){ 1 << 2 } },
	{ MODKEY|ControlMask,           XK_4,      toggleview,     (uint[]){ 1 << 3 } },
	{ MODKEY|ControlMask,           XK_5,      toggleview,     (uint[]){ 1 << 4 } },
	{ MODKEY|ControlMask,           XK_6,      toggleview,     (uint[]){ 1 << 5 } },
	{ MODKEY|ControlMask,           XK_7,      toggleview,     (uint[]){ 1 << 6 } },
	{ MODKEY|ControlMask,           XK_8,      toggleview,     (uint[]){ 1 << 7 } },
	{ MODKEY|ControlMask,           XK_9,      toggleview,     (uint[]){ 1 << 8 } },
	{ MODKEY|ShiftMask,             XK_0,      tag,            (uint[]){ ~0 } },
	{ MODKEY|ShiftMask,             XK_1,      tag,            (uint[]){ 1 << 0 } },
	{ MODKEY|ShiftMask,             XK_2,      tag,            (uint[]){ 1 << 1 } },
	{ MODKEY|ShiftMask,             XK_3,      tag,            (uint[]){ 1 << 2 } },
	{ MODKEY|ShiftMask,             XK_4,      tag,            (uint[]){ 1 << 3 } },
	{ MODKEY|ShiftMask,             XK_5,      tag,            (uint[]){ 1 << 4 } },
	{ MODKEY|ShiftMask,             XK_6,      tag,            (uint[]){ 1 << 5 } },
	{ MODKEY|ShiftMask,             XK_7,      tag,            (uint[]){ 1 << 6 } },
	{ MODKEY|ShiftMask,             XK_8,      tag,            (uint[]){ 1 << 7 } },
	{ MODKEY|ShiftMask,             XK_9,      tag,            (uint[]){ 1 << 8 } },
	{ MODKEY|ControlMask|ShiftMask, XK_1,      toggletag,      (uint[]){ 1 << 0 } },
	{ MODKEY|ControlMask|ShiftMask, XK_2,      toggletag,      (uint[]){ 1 << 1 } },
	{ MODKEY|ControlMask|ShiftMask, XK_3,      toggletag,      (uint[]){ 1 << 2 } },
	{ MODKEY|ControlMask|ShiftMask, XK_4,      toggletag,      (uint[]){ 1 << 3 } },
	{ MODKEY|ControlMask|ShiftMask, XK_5,      toggletag,      (uint[]){ 1 << 4 } },
	{ MODKEY|ControlMask|ShiftMask, XK_6,      toggletag,      (uint[]){ 1 << 5 } },
	{ MODKEY|ControlMask|ShiftMask, XK_7,      toggletag,      (uint[]){ 1 << 6 } },
	{ MODKEY|ControlMask|ShiftMask, XK_8,      toggletag,      (uint[]){ 1 << 7 } },
	{ MODKEY|ControlMask|ShiftMask, XK_9,      toggletag,      (uint[]){ 1 << 8 } },
	TAGKEYS(                        XK_1,                      (uint[]){ 1 << 0} )
	TAGKEYS(                        XK_2,                      (uint[]){ 1 << 1} )
	TAGKEYS(                        XK_3,                      (uint[]){ 1 << 2} )
	TAGKEYS(                        XK_4,                      (uint[]){ 1 << 3} )
	TAGKEYS(                        XK_5,                      (uint[]){ 1 << 4} )
	TAGKEYS(                        XK_6,                      (uint[]){ 1 << 5} )
	TAGKEYS(                        XK_7,                      (uint[]){ 1 << 6} )
	TAGKEYS(                        XK_8,                      (uint[]){ 1 << 7} )
	TAGKEYS(                        XK_9,                      (uint[]){ 1 << 8} )
	{ MODKEY|ShiftMask,             XK_q,      quit,           NULL },
};

dwm.1 +3 −0

.B Mod1\-l
Increase master area size.
.TP
.B Mod1\-m
Toggle focused window between maximisation and normal state.
.TP
.B Mod1\-Return
Zooms/cycles focused window to/from master area (tiled layouts only).
.TP

dwm.c +36 −40

	int minax, maxax, minay, maxay;
	long flags;
	int bw, oldbw;
	Bool isbanned, isfixed, isfloating, isurgent;
	Bool isbanned, isfixed, isfloating, ismax, isurgent;
	uint tags;
	Client *next;
	Client *prev;

void arrange(void);
void attach(Client *c);
void attachstack(Client *c);
void ban(Client *c);
void buttonpress(XEvent *e);
void checkotherwm(void);
void cleanup(void);

void togglebar(const void *arg);
void togglefloating(const void *arg);
void togglelayout(const void *arg);
void togglemax(const void *arg);
void toggletag(const void *arg);
void toggleview(const void *arg);
void unban(Client *c);
void unmanage(Client *c);
void unmapnotify(XEvent *e);
void updatebar(void);

	[UnmapNotify] = unmapnotify
};
Atom wmatom[WMLast], netatom[NetLast];
Bool domax = False;
Bool otherwm, readin;
Bool running = True;
uint tagset[] = {1, 1}; /* after start, first tag is selected */


	for(c = clients; c; c = c->next)
		if(VISIBLE(c)) {
			unban(c);
			if(!lt->arrange || c->isfloating)
				resize(c, c->x, c->y, c->w, c->h, True);
		}
		else
			ban(c);
		else if(!c->isbanned) {
			XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
			c->isbanned = True;
		}

	focus(NULL);
	if(lt->arrange)
	if(lt->arrange && !domax)
		lt->arrange();
	restack();
}

}

void
ban(Client *c) {
	if(c->isbanned)
		return;
	XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
	c->isbanned = True;
}

void
buttonpress(XEvent *e) {
	uint i, x, mask;
	Client *c;

				return;
			}
		}
		if((ev->x < x + blw) && ev->button == Button1) 
			togglelayout(NULL);
		if(ev->x < x + blw) {
			if(ev->button == Button1) 
				togglelayout(NULL);
			else if(ev->button == Button3) 
				togglemax(NULL);
		}
	}
	else if((c = getclient(ev->window))) {
		focus(c);
		if(CLEANMASK(ev->state) != MODKEY)
		if(CLEANMASK(ev->state) != MODKEY || domax)
			return;
		if(ev->button == Button1) {
			restack();
		if(ev->button == Button1)
			movemouse(c);
		}
		else if(ev->button == Button2)
			togglefloating(NULL);
		else if(ev->button == Button3 && !c->isfixed) {
			restack();
		else if(ev->button == Button3 && !c->isfixed)
			resizemouse(c);
		}
	}
}


void
cleanup(void) {
	close(STDIN_FILENO);
	while(stack) {
		unban(stack);
	view(NULL);
	while(stack)
		unmanage(stack);
	}
	if(dc.font.set)
		XFreeFontSet(dpy, dc.font.set);
	else

	}
	if(blw > 0) {
		dc.w = blw;
		drawtext(lt->symbol, dc.norm, False);
		drawtext(lt->symbol, dc.norm, domax);
		x = dc.x + dc.w;
	}
	else

	}
	sel = c;
	if(c) {
		if(domax) {
			XMoveResizeWindow(dpy, c->win, wx, wy, ww - 2 * c->bw, wh - 2 * c->bw);
			c->ismax = True;
		}
		XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
	}

	attach(c);
	attachstack(c);
	XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h); /* some windows require this */
	ban(c);
	XMapWindow(dpy, c->win);
	setclientstate(c, NormalState);
	arrange();

	Window dummy;
	XEvent ev;

	restack();
	ocx = nx = c->x;
	ocy = ny = c->y;
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,

		x = sx;
	if(y + h + 2 * c->bw < sy)
		y = sy;
	if(c->x != x || c->y != y || c->w != w || c->h != h) {
	if(c->x != x || c->y != y || c->w != w || c->h != h || c->isbanned || c->ismax) {
		c->isbanned = c->ismax = False;
		c->x = wc.x = x;
		c->y = wc.y = y;
		c->w = wc.width = w;

	int nw, nh;
	XEvent ev;

	restack();
	ocx = c->x;
	ocy = c->y;
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,

	drawbar();
	if(!sel)
		return;
	if(sel->isfloating || !lt->arrange)
	if(domax || sel->isfloating || !lt->arrange)
		XRaiseWindow(dpy, sel->win);
	if(lt->arrange) {
	if(!domax && lt->arrange) {
		wc.stack_mode = Below;
		wc.sibling = barwin;
		for(c = stack; c; c = c->snext)

}

void
togglemax(const void *arg) {
	domax = !domax;
	arrange();
}

void
toggletag(const void *arg) {
	if(sel && (sel->tags ^ ((*(int *)arg) & TAGMASK))) {
		sel->tags ^= (*(int *)arg) & TAGMASK;

		tagset[seltags] ^= (*(int *)arg) & TAGMASK;
		arrange();
	}
}

void
unban(Client *c) {
	if(!c->isbanned)
		return;
	XMoveWindow(dpy, c->win, c->x, c->y);
	c->isbanned = False;
}

void

34	34
35	35		/* key definitions */
36	36		#define MODKEY Mod1Mask
	37	+	#define TAGKEYS(KEY,TAG) \
	38	+	{ MODKEY, KEY, view, TAG }, \
	39	+	{ MODKEY\|ControlMask, KEY, toggleview, TAG }, \
	40	+	{ MODKEY\|ShiftMask, KEY, tag, TAG }, \
	41	+	{ MODKEY\|ControlMask\|ShiftMask, KEY, toggletag, TAG },
	42	+
37	43		Key keys[] = {
38	44		/* modifier key function argument */
39	45		{ MODKEY, XK_p, spawn, (char *)"exec dmenu_run -fn '"FONT"' -nb '"NORMBGCOLOR"' -nf '"NORMFGCOLOR"' -sb '"SELBGCOLOR"' -sf '"SELFGCOLOR"'" },

43	49		{ MODKEY, XK_k, focusprev, NULL },
44	50		{ MODKEY, XK_h, setmfact, (double[]){-0.05} },
45	51		{ MODKEY, XK_l, setmfact, (double[]){+0.05} },
	52	+	{ MODKEY, XK_m, togglemax, NULL },
46	53		{ MODKEY, XK_Return, zoom, NULL },
47	54		{ MODKEY, XK_Tab, viewprevtag, NULL },
48	55		{ MODKEY\|ShiftMask, XK_c, killclient, NULL },
49	56		{ MODKEY, XK_space, togglelayout, NULL },
50	57		{ MODKEY\|ShiftMask, XK_space, togglefloating, NULL },
51	58		{ MODKEY, XK_0, view, (uint[]){ ~0 } },
52		-	{ MODKEY, XK_1, view, (uint[]){ 1 << 0 } },
53		-	{ MODKEY, XK_2, view, (uint[]){ 1 << 1 } },
54		-	{ MODKEY, XK_3, view, (uint[]){ 1 << 2 } },
55		-	{ MODKEY, XK_4, view, (uint[]){ 1 << 3 } },
56		-	{ MODKEY, XK_5, view, (uint[]){ 1 << 4 } },
57		-	{ MODKEY, XK_6, view, (uint[]){ 1 << 5 } },
58		-	{ MODKEY, XK_7, view, (uint[]){ 1 << 6 } },
59		-	{ MODKEY, XK_8, view, (uint[]){ 1 << 7 } },
60		-	{ MODKEY, XK_9, view, (uint[]){ 1 << 8 } },
61		-	{ MODKEY\|ControlMask, XK_1, toggleview, (uint[]){ 1 << 0 } },
62		-	{ MODKEY\|ControlMask, XK_2, toggleview, (uint[]){ 1 << 1 } },
63		-	{ MODKEY\|ControlMask, XK_3, toggleview, (uint[]){ 1 << 2 } },
64		-	{ MODKEY\|ControlMask, XK_4, toggleview, (uint[]){ 1 << 3 } },
65		-	{ MODKEY\|ControlMask, XK_5, toggleview, (uint[]){ 1 << 4 } },
66		-	{ MODKEY\|ControlMask, XK_6, toggleview, (uint[]){ 1 << 5 } },
67		-	{ MODKEY\|ControlMask, XK_7, toggleview, (uint[]){ 1 << 6 } },
68		-	{ MODKEY\|ControlMask, XK_8, toggleview, (uint[]){ 1 << 7 } },
69		-	{ MODKEY\|ControlMask, XK_9, toggleview, (uint[]){ 1 << 8 } },
70	59		{ MODKEY\|ShiftMask, XK_0, tag, (uint[]){ ~0 } },
71		-	{ MODKEY\|ShiftMask, XK_1, tag, (uint[]){ 1 << 0 } },
72		-	{ MODKEY\|ShiftMask, XK_2, tag, (uint[]){ 1 << 1 } },
73		-	{ MODKEY\|ShiftMask, XK_3, tag, (uint[]){ 1 << 2 } },
74		-	{ MODKEY\|ShiftMask, XK_4, tag, (uint[]){ 1 << 3 } },
75		-	{ MODKEY\|ShiftMask, XK_5, tag, (uint[]){ 1 << 4 } },
76		-	{ MODKEY\|ShiftMask, XK_6, tag, (uint[]){ 1 << 5 } },
77		-	{ MODKEY\|ShiftMask, XK_7, tag, (uint[]){ 1 << 6 } },
78		-	{ MODKEY\|ShiftMask, XK_8, tag, (uint[]){ 1 << 7 } },
79		-	{ MODKEY\|ShiftMask, XK_9, tag, (uint[]){ 1 << 8 } },
80		-	{ MODKEY\|ControlMask\|ShiftMask, XK_1, toggletag, (uint[]){ 1 << 0 } },
81		-	{ MODKEY\|ControlMask\|ShiftMask, XK_2, toggletag, (uint[]){ 1 << 1 } },
82		-	{ MODKEY\|ControlMask\|ShiftMask, XK_3, toggletag, (uint[]){ 1 << 2 } },
83		-	{ MODKEY\|ControlMask\|ShiftMask, XK_4, toggletag, (uint[]){ 1 << 3 } },
84		-	{ MODKEY\|ControlMask\|ShiftMask, XK_5, toggletag, (uint[]){ 1 << 4 } },
85		-	{ MODKEY\|ControlMask\|ShiftMask, XK_6, toggletag, (uint[]){ 1 << 5 } },
86		-	{ MODKEY\|ControlMask\|ShiftMask, XK_7, toggletag, (uint[]){ 1 << 6 } },
87		-	{ MODKEY\|ControlMask\|ShiftMask, XK_8, toggletag, (uint[]){ 1 << 7 } },
88		-	{ MODKEY\|ControlMask\|ShiftMask, XK_9, toggletag, (uint[]){ 1 << 8 } },
	60	+	TAGKEYS( XK_1, (uint[]){ 1 << 0} )
	61	+	TAGKEYS( XK_2, (uint[]){ 1 << 1} )
	62	+	TAGKEYS( XK_3, (uint[]){ 1 << 2} )
	63	+	TAGKEYS( XK_4, (uint[]){ 1 << 3} )
	64	+	TAGKEYS( XK_5, (uint[]){ 1 << 4} )
	65	+	TAGKEYS( XK_6, (uint[]){ 1 << 5} )
	66	+	TAGKEYS( XK_7, (uint[]){ 1 << 6} )
	67	+	TAGKEYS( XK_8, (uint[]){ 1 << 7} )
	68	+	TAGKEYS( XK_9, (uint[]){ 1 << 8} )
89	69		{ MODKEY\|ShiftMask, XK_q, quit, NULL },
90	70		};

75	75		.B Mod1\-l
76	76		Increase master area size.
77	77		.TP
	78	+	.B Mod1\-m
	79	+	Toggle focused window between maximisation and normal state.
	80	+	.TP
78	81		.B Mod1\-Return
79	82		Zooms/cycles focused window to/from master area (tiled layouts only).
80	83		.TP

71	71		int minax, maxax, minay, maxay;
72	72		long flags;
73	73		int bw, oldbw;
74		-	Bool isbanned, isfixed, isfloating, isurgent;
	74	+	Bool isbanned, isfixed, isfloating, ismax, isurgent;
75	75		uint tags;
76	76		Client *next;
77	77		Client *prev;

120	120		void arrange(void);
121	121		void attach(Client *c);
122	122		void attachstack(Client *c);
123		-	void ban(Client *c);
124	123		void buttonpress(XEvent *e);
125	124		void checkotherwm(void);
126	125		void cleanup(void);

176	175		void togglebar(const void *arg);
177	176		void togglefloating(const void *arg);
178	177		void togglelayout(const void *arg);
	178	+	void togglemax(const void *arg);
179	179		void toggletag(const void *arg);
180	180		void toggleview(const void *arg);
181		-	void unban(Client *c);
182	181		void unmanage(Client *c);
183	182		void unmapnotify(XEvent *e);
184	183		void updatebar(void);

217	216		[UnmapNotify] = unmapnotify
218	217		};
219	218		Atom wmatom[WMLast], netatom[NetLast];
	219	+	Bool domax = False;
220	220		Bool otherwm, readin;
221	221		Bool running = True;
222	222		uint tagset[] = {1, 1}; /* after start, first tag is selected */

268	268
269	269		for(c = clients; c; c = c->next)
270	270		if(VISIBLE(c)) {
271		-	unban(c);
272	271		if(!lt->arrange \|\| c->isfloating)
273	272		resize(c, c->x, c->y, c->w, c->h, True);
274	273		}
275		-	else
276		-	ban(c);
	274	+	else if(!c->isbanned) {
	275	+	XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
	276	+	c->isbanned = True;
	277	+	}
277	278
278	279		focus(NULL);
279		-	if(lt->arrange)
	280	+	if(lt->arrange && !domax)
280	281		lt->arrange();
281	282		restack();
282	283		}

296	297		}
297	298
298	299		void
299		-	ban(Client *c) {
300		-	if(c->isbanned)
301		-	return;
302		-	XMoveWindow(dpy, c->win, c->x + 2 * sw, c->y);
303		-	c->isbanned = True;
304		-	}
305		-
306		-	void
307	300		buttonpress(XEvent *e) {
308	301		uint i, x, mask;
309	302		Client *c;

330	323		return;
331	324		}
332	325		}
333		-	if((ev->x < x + blw) && ev->button == Button1)
334		-	togglelayout(NULL);
	326	+	if(ev->x < x + blw) {
	327	+	if(ev->button == Button1)
	328	+	togglelayout(NULL);
	329	+	else if(ev->button == Button3)
	330	+	togglemax(NULL);
	331	+	}
335	332		}
336	333		else if((c = getclient(ev->window))) {
337	334		focus(c);
338		-	if(CLEANMASK(ev->state) != MODKEY)
	335	+	if(CLEANMASK(ev->state) != MODKEY \|\| domax)
339	336		return;
340		-	if(ev->button == Button1) {
341		-	restack();
	337	+	if(ev->button == Button1)
342	338		movemouse(c);
343		-	}
344	339		else if(ev->button == Button2)
345	340		togglefloating(NULL);
346		-	else if(ev->button == Button3 && !c->isfixed) {
347		-	restack();
	341	+	else if(ev->button == Button3 && !c->isfixed)
348	342		resizemouse(c);
349		-	}
350	343		}
351	344		}
352	345

369	362		void
370	363		cleanup(void) {
371	364		close(STDIN_FILENO);
372		-	while(stack) {
373		-	unban(stack);
	365	+	view(NULL);
	366	+	while(stack)
374	367		unmanage(stack);
375		-	}
376	368		if(dc.font.set)
377	369		XFreeFontSet(dpy, dc.font.set);
378	370		else

512	504		}
513	505		if(blw > 0) {
514	506		dc.w = blw;
515		-	drawtext(lt->symbol, dc.norm, False);
	507	+	drawtext(lt->symbol, dc.norm, domax);
516	508		x = dc.x + dc.w;
517	509		}
518	510		else

641	633		}
642	634		sel = c;
643	635		if(c) {
	636	+	if(domax) {
	637	+	XMoveResizeWindow(dpy, c->win, wx, wy, ww - 2 * c->bw, wh - 2 * c->bw);
	638	+	c->ismax = True;
	639	+	}
644	640		XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
645	641		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
646	642		}

960	956		attach(c);
961	957		attachstack(c);
962	958		XMoveResizeWindow(dpy, c->win, c->x, c->y, c->w, c->h); /* some windows require this */
963		-	ban(c);
964	959		XMapWindow(dpy, c->win);
965	960		setclientstate(c, NormalState);
966	961		arrange();

995	990		Window dummy;
996	991		XEvent ev;
997	992
	993	+	restack();
998	994		ocx = nx = c->x;
999	995		ocy = ny = c->y;
1000	996		if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,

1130	1126		x = sx;
1131	1127		if(y + h + 2 * c->bw < sy)
1132	1128		y = sy;
1133		-	if(c->x != x \|\| c->y != y \|\| c->w != w \|\| c->h != h) {
	1129	+	if(c->x != x \|\| c->y != y \|\| c->w != w \|\| c->h != h \|\| c->isbanned \|\| c->ismax) {
	1130	+	c->isbanned = c->ismax = False;
1134	1131		c->x = wc.x = x;
1135	1132		c->y = wc.y = y;
1136	1133		c->w = wc.width = w;

1149	1146		int nw, nh;
1150	1147		XEvent ev;
1151	1148
	1149	+	restack();
1152	1150		ocx = c->x;
1153	1151		ocy = c->y;
1154	1152		if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,

1196	1194		drawbar();
1197	1195		if(!sel)
1198	1196		return;
1199		-	if(sel->isfloating \|\| !lt->arrange)
	1197	+	if(domax \|\| sel->isfloating \|\| !lt->arrange)
1200	1198		XRaiseWindow(dpy, sel->win);
1201		-	if(lt->arrange) {
	1199	+	if(!domax && lt->arrange) {
1202	1200		wc.stack_mode = Below;
1203	1201		wc.sibling = barwin;
1204	1202		for(c = stack; c; c = c->snext)

1532	1530		}
1533	1531
1534	1532		void
	1533	+	togglemax(const void *arg) {
	1534	+	domax = !domax;
	1535	+	arrange();
	1536	+	}
	1537	+
	1538	+	void
1535	1539		toggletag(const void *arg) {
1536	1540		if(sel && (sel->tags ^ (((int )arg) & TAGMASK))) {
1537	1541		sel->tags ^= ((int )arg) & TAGMASK;

1545	1549		tagset[seltags] ^= ((int )arg) & TAGMASK;
1546	1550		arrange();
1547	1551		}
1548		-	}
1549		-
1550		-	void
1551		-	unban(Client *c) {
1552		-	if(!c->isbanned)
1553		-	return;
1554		-	XMoveWindow(dpy, c->win, c->x, c->y);
1555		-	c->isbanned = False;
1556	1552		}
1557	1553
1558	1554		void