git.stevedylan.dev

some more changes towards a better dwm 2f70a14e

Anselm R Garbe · 2008-02-28 17:07 2 file(s) · +49 −61

config.def.h +1 −1

#define SELBGCOLOR		"#0066ff"
#define SELFGCOLOR		"#ffffff"

/* tagging */
/* old */
const char tags[][MAXTAGLEN]     = { "1", "2", "3", "4", "nil", "6", "7", "8", "www" };
unsigned int vtags[LENGTH(tags)] = {  0 ,  0 ,  0 ,  0 ,   0  ,  1 ,  1 ,  1 ,   1   };
Bool initags[LENGTH(tags)]       = { [0] = True, [5] = True };

dwm.c +48 −60

	unsigned int border, oldborder;
	Bool isbanned, isfixed, isfloating, isurgent;
	Bool *tags;
	View *view;
	Client *next;
	Client *prev;
	Client *snext;

	Bool isfloating;
} Rule;

typedef struct {
	const char name[MAXTAGLEN];
	unsigned int view;
} Tag;

struct View {
	unsigned int id;
	int x, y, w, h, wax, way, wah, waw;
	double mwfact;
	Layout *layout;

void detach(Client *c);
void detachstack(Client *c);
void drawbar(View *v);
void drawsquare(View *v, Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]);
void drawtext(View *v, const char *text, unsigned long col[ColLast], Bool invert);
void drawsquare(Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]);
void drawtext(const char *text, unsigned long col[ColLast], Bool invert);
void *emallocz(unsigned int size);
void enternotify(XEvent *e);
void eprint(const char *errstr, ...);

Client *getclient(Window w);
unsigned long getcolor(const char *colstr);
View *getviewbar(Window barwin);
View *getview(Client *c);
long getstate(Window w);
Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
void grabbuttons(Client *c, Bool focused);

/* variables */
char stext[256], buf[256];
int nviews = 1;
View *selview;
int screen;
int (*xerrorxlib)(Display *, XErrorEvent *);
unsigned int bh, bpos;

Display *dpy;
DC dc = {0};
View *views;
View *selview;
Window root;

/* configuration, allows nested code to access above variables */

		if(c->tags[i] && vtags[i] != vtags[tidx])
			return; /* conflict */
	c->tags[tidx] = True;
	c->view = &views[vtags[tidx]];
}

void

		XFree(ch.res_class);
	if(ch.res_name)
		XFree(ch.res_name);
	if(!matched)
	if(!matched) {
		memcpy(c->tags, seltags, sizeof initags);
		c->view = selview;
	}
}



ban(Client *c) {
	if(c->isbanned)
		return;
	XMoveWindow(dpy, c->win, c->x + 3 * getview(c)->w, c->y);
	XMoveWindow(dpy, c->win, c->x + 3 * c->view->w, c->y);
	c->isbanned = True;
}


	Client *c;
	XButtonPressedEvent *ev = &e->xbutton;

	View *v = selview;

	if(ev->window == v->barwin) {
	if(ev->window == selview->barwin) {
		x = 0;
		for(i = 0; i < LENGTH(tags); i++) {
			x += textw(tags[i]);

		if(CLEANMASK(ev->state) != MODKEY)
			return;
		if(ev->button == Button1) {
			restack(getview(c));
			restack(c->view);
			movemouse(c);
		}
		else if(ev->button == Button2) {
			if((floating != v->layout->arrange) && c->isfloating)
			if((floating != c->view->layout->arrange) && c->isfloating)
				togglefloating(NULL);
			else
				zoom(NULL);
		}
		else if(ev->button == Button3 && !c->isfixed) {
			restack(getview(c));
			restack(c->view);
			resizemouse(c);
		}
	}

		XFreePixmap(dpy, dc.drawable);
		dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(root, screen), bh, DefaultDepth(dpy, screen));
		XResizeWindow(dpy, v->barwin, v->w, bh);
		updatebarpos(v);
		updatebarpos(selview);
		arrange();
	}
}

	XWindowChanges wc;

	if((c = getclient(ev->window))) {
		View *v = getview(c);
		View *v = c->view;
		if(ev->value_mask & CWBorderWidth)
			c->border = ev->border_width;
		if(c->isfixed || c->isfloating || (floating == v->layout->arrange)) {

	Client *c;

	dc.x = 0;
	for(c = stack; c && (!isvisible(c) || getview(c) != v); c = c->snext);
	for(c = stack; c && (!isvisible(c) || c->view != v); c = c->snext);
	for(i = 0; i < LENGTH(tags); i++) {
		if(&views[vtags[i]] != v)
			continue;
		dc.w = textw(tags[i]);
		if(seltags[i]) {
			drawtext(v, tags[i], dc.sel, isurgent(i));
			drawsquare(v, c && c->tags[i], isoccupied(i), isurgent(i), dc.sel);
			drawtext(tags[i], dc.sel, isurgent(i));
			drawsquare(c && c->tags[i], isoccupied(i), isurgent(i), dc.sel);
		}
		else {
			drawtext(v, tags[i], dc.norm, isurgent(i));
			drawsquare(v, c && c->tags[i], isoccupied(i), isurgent(i), dc.norm);
			drawtext(tags[i], dc.norm, isurgent(i));
			drawsquare(c && c->tags[i], isoccupied(i), isurgent(i), dc.norm);
		}
		dc.x += dc.w;
	}
	dc.w = blw;
	drawtext(v, v->layout->symbol, dc.norm, False);
	drawtext(v->layout->symbol, dc.norm, False);
	x = dc.x + dc.w;
	if(v == selview) {
		dc.w = textw(stext);

			dc.x = x;
			dc.w = v->w - x;
		}
		drawtext(v, stext, dc.norm, False);
		drawtext(stext, dc.norm, False);
	}
	else
		dc.x = v->w;
	if((dc.w = dc.x - x) > bh) {
		dc.x = x;
		if(c) {
			drawtext(v, c->name, dc.sel, False);
			drawsquare(v, False, c->isfloating, False, dc.sel);
			drawtext(c->name, dc.sel, False);
			drawsquare(False, c->isfloating, False, dc.sel);
		}
		else
			drawtext(v, NULL, dc.norm, False);
			drawtext(NULL, dc.norm, False);
	}
	XCopyArea(dpy, dc.drawable, v->barwin, dc.gc, 0, 0, v->w, bh, 0, 0);
	XSync(dpy, False);
}

void
drawsquare(View *v, Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]) {
drawsquare(Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]) {
	int x;
	XGCValues gcv;
	XRectangle r = { dc.x, dc.y, dc.w, dc.h };

}

void
drawtext(View *v, const char *text, unsigned long col[ColLast], Bool invert) {
drawtext(const char *text, unsigned long col[ColLast], Bool invert) {
	int x, y, w, h;
	unsigned int len, olen;
	XRectangle r = { dc.x, dc.y, dc.w, dc.h };

	View *v;
	XExposeEvent *ev = &e->xexpose;

	if(ev->count == 0 && (v = getviewbar(ev->window)))
	if(ev->count == 0 && ((v = getviewbar(ev->window))))
		drawbar(v);
}


focus(Client *c) {
	View *v = selview;
	if(c)
		selview = getview(c);
		selview = c->view;
	else
		selview = viewat();
	if(selview != v)
		drawbar(v);
	if(!c || (c && !isvisible(c)))
		for(c = stack; c && (!isvisible(c) || getview(c) != selview); c = c->snext);
		for(c = stack; c && (!isvisible(c) || c->view != selview); c = c->snext);
	if(sel && sel != c) {
		grabbuttons(sel, False);
		XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);

	if(c) {
		XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
		selview = getview(c);
		selview = c->view;
	}
	else
		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);

		for(c = clients; c && !isvisible(c); c = c->next);
	if(c) {
		focus(c);
		restack(getview(c));
		restack(c->view);
	}
}


	}
	if(c) {
		focus(c);
		restack(getview(c));
		restack(c->view);
	}
}


	return NULL;
}

View *
getview(Client *c) {
	unsigned int i;

	for(i = 0; i < LENGTH(tags); i++)
		if(c->tags[i])
			return &views[c->tags[i] - 1];
	return &views[0]; /* fallback */
}

long
getstate(Window w) {
	int format, status;


	applyrules(c);

	v = getview(c);
	v = c->view;

	c->x = wa->x + v->x;
	c->y = wa->y + v->y;


	ocx = nx = c->x;
	ocy = ny = c->y;
	v = getview(c);
	v = c->view;
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
			None, cursor[CurMove], CurrentTime) != GrabSuccess)
		return;


Client *
nexttiled(Client *c, View *v) {
	for(; c && (c->isfloating || getview(c) != v || !isvisible(c)); c = c->next);
	for(; c && (c->isfloating || c->view != v || !isvisible(c)); c = c->next);
	return c;
}


			break;
		case XA_WM_HINTS:
			updatewmhints(c);
			drawbar(getview(c));
			drawbar(c->view);
			break;
		}
		if(ev->atom == XA_WM_NAME || ev->atom == netatom[NetWMName]) {

	View *v;
	XWindowChanges wc;

	v = getview(c);
	v = c->view;
	if(sizehints) {
		/* set minimum possible */
		if (w < 1)


	ocx = c->x;
	ocy = c->y;
	v = getview(c);
	v = c->view;
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
			None, cursor[CurResize], CurrentTime) != GrabSuccess)
		return;

	if(sel)
		arrange();
	else
		drawbar(v);
		drawbar(selview);
}

void
setmwfact(const char *arg) {
	double delta;

	View *v = selview;

	if(!domwfact)

isxinerama = True;
nviews = 2; /* aim Xinerama */
#endif
	selview = views = emallocz(nviews * sizeof(View));
	views = emallocz(nviews * sizeof(View));

	screen = DefaultScreen(dpy);
	root = RootWindow(dpy, screen);

	if(info)
		XFree(info);

	selview = viewat();

	/* grab keys */
	grabkeys();

	selview = &views[0];
}

void


	if(!sel || !dozoom || sel->isfloating)
		return;
	if(c == nexttiled(clients, getview(c)))
		if(!(c = nexttiled(c->next, getview(c))))
	if(c == nexttiled(clients, c->view))
		if(!(c = nexttiled(c->next, c->view)))
			return;
	detach(c);
	attach(c);

11	11		#define SELBGCOLOR "#0066ff"
12	12		#define SELFGCOLOR "#ffffff"
13	13
14		-	/* tagging */
	14	+	/* old */
15	15		const char tags[][MAXTAGLEN] = { "1", "2", "3", "4", "nil", "6", "7", "8", "www" };
16	16		unsigned int vtags[LENGTH(tags)] = { 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 };
17	17		Bool initags[LENGTH(tags)] = { [0] = True, [5] = True };

71	71		unsigned int border, oldborder;
72	72		Bool isbanned, isfixed, isfloating, isurgent;
73	73		Bool *tags;
	74	+	View *view;
74	75		Client *next;
75	76		Client *prev;
76	77		Client *snext;

110	111		Bool isfloating;
111	112		} Rule;
112	113
113		-	typedef struct {
114		-	const char name[MAXTAGLEN];
115		-	unsigned int view;
116		-	} Tag;
117		-
118	114		struct View {
	115	+	unsigned int id;
119	116		int x, y, w, h, wax, way, wah, waw;
120	117		double mwfact;
121	118		Layout *layout;

139	136		void detach(Client *c);
140	137		void detachstack(Client *c);
141	138		void drawbar(View *v);
142		-	void drawsquare(View *v, Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]);
143		-	void drawtext(View v, const char text, unsigned long col[ColLast], Bool invert);
	139	+	void drawsquare(Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]);
	140	+	void drawtext(const char *text, unsigned long col[ColLast], Bool invert);
144	141		void *emallocz(unsigned int size);
145	142		void enternotify(XEvent *e);
146	143		void eprint(const char *errstr, ...);

153	150		Client *getclient(Window w);
154	151		unsigned long getcolor(const char *colstr);
155	152		View *getviewbar(Window barwin);
156		-	View getview(Client c);
157	153		long getstate(Window w);
158	154		Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
159	155		void grabbuttons(Client *c, Bool focused);

211	207		/* variables */
212	208		char stext[256], buf[256];
213	209		int nviews = 1;
214		-	View *selview;
215	210		int screen;
216	211		int (xerrorxlib)(Display , XErrorEvent *);
217	212		unsigned int bh, bpos;

246	241		Display *dpy;
247	242		DC dc = {0};
248	243		View *views;
	244	+	View *selview;
249	245		Window root;
250	246
251	247		/* configuration, allows nested code to access above variables */

260	256		if(c->tags[i] && vtags[i] != vtags[tidx])
261	257		return; /* conflict */
262	258		c->tags[tidx] = True;
	259	+	c->view = &views[vtags[tidx]];
263	260		}
264	261
265	262		void

288	285		XFree(ch.res_class);
289	286		if(ch.res_name)
290	287		XFree(ch.res_name);
291		-	if(!matched)
	288	+	if(!matched) {
292	289		memcpy(c->tags, seltags, sizeof initags);
	290	+	c->view = selview;
	291	+	}
293	292		}
294	293
295	294

330	329		ban(Client *c) {
331	330		if(c->isbanned)
332	331		return;
333		-	XMoveWindow(dpy, c->win, c->x + 3 * getview(c)->w, c->y);
	332	+	XMoveWindow(dpy, c->win, c->x + 3 * c->view->w, c->y);
334	333		c->isbanned = True;
335	334		}
336	335

340	339		Client *c;
341	340		XButtonPressedEvent *ev = &e->xbutton;
342	341
343		-	View *v = selview;
344		-
345		-	if(ev->window == v->barwin) {
	342	+	if(ev->window == selview->barwin) {
346	343		x = 0;
347	344		for(i = 0; i < LENGTH(tags); i++) {
348	345		x += textw(tags[i]);

370	367		if(CLEANMASK(ev->state) != MODKEY)
371	368		return;
372	369		if(ev->button == Button1) {
373		-	restack(getview(c));
	370	+	restack(c->view);
374	371		movemouse(c);
375	372		}
376	373		else if(ev->button == Button2) {
377		-	if((floating != v->layout->arrange) && c->isfloating)
	374	+	if((floating != c->view->layout->arrange) && c->isfloating)
378	375		togglefloating(NULL);
379	376		else
380	377		zoom(NULL);
381	378		}
382	379		else if(ev->button == Button3 && !c->isfixed) {
383		-	restack(getview(c));
	380	+	restack(c->view);
384	381		resizemouse(c);
385	382		}
386	383		}

457	454		XFreePixmap(dpy, dc.drawable);
458	455		dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(root, screen), bh, DefaultDepth(dpy, screen));
459	456		XResizeWindow(dpy, v->barwin, v->w, bh);
460		-	updatebarpos(v);
	457	+	updatebarpos(selview);
461	458		arrange();
462	459		}
463	460		}

469	466		XWindowChanges wc;
470	467
471	468		if((c = getclient(ev->window))) {
472		-	View *v = getview(c);
	469	+	View *v = c->view;
473	470		if(ev->value_mask & CWBorderWidth)
474	471		c->border = ev->border_width;
475	472		if(c->isfixed \|\| c->isfloating \|\| (floating == v->layout->arrange)) {

541	538		Client *c;
542	539
543	540		dc.x = 0;
544		-	for(c = stack; c && (!isvisible(c) \|\| getview(c) != v); c = c->snext);
	541	+	for(c = stack; c && (!isvisible(c) \|\| c->view != v); c = c->snext);
545	542		for(i = 0; i < LENGTH(tags); i++) {
	543	+	if(&views[vtags[i]] != v)
	544	+	continue;
546	545		dc.w = textw(tags[i]);
547	546		if(seltags[i]) {
548		-	drawtext(v, tags[i], dc.sel, isurgent(i));
549		-	drawsquare(v, c && c->tags[i], isoccupied(i), isurgent(i), dc.sel);
	547	+	drawtext(tags[i], dc.sel, isurgent(i));
	548	+	drawsquare(c && c->tags[i], isoccupied(i), isurgent(i), dc.sel);
550	549		}
551	550		else {
552		-	drawtext(v, tags[i], dc.norm, isurgent(i));
553		-	drawsquare(v, c && c->tags[i], isoccupied(i), isurgent(i), dc.norm);
	551	+	drawtext(tags[i], dc.norm, isurgent(i));
	552	+	drawsquare(c && c->tags[i], isoccupied(i), isurgent(i), dc.norm);
554	553		}
555	554		dc.x += dc.w;
556	555		}
557	556		dc.w = blw;
558		-	drawtext(v, v->layout->symbol, dc.norm, False);
	557	+	drawtext(v->layout->symbol, dc.norm, False);
559	558		x = dc.x + dc.w;
560	559		if(v == selview) {
561	560		dc.w = textw(stext);

564	563		dc.x = x;
565	564		dc.w = v->w - x;
566	565		}
567		-	drawtext(v, stext, dc.norm, False);
	566	+	drawtext(stext, dc.norm, False);
568	567		}
569	568		else
570	569		dc.x = v->w;
571	570		if((dc.w = dc.x - x) > bh) {
572	571		dc.x = x;
573	572		if(c) {
574		-	drawtext(v, c->name, dc.sel, False);
575		-	drawsquare(v, False, c->isfloating, False, dc.sel);
	573	+	drawtext(c->name, dc.sel, False);
	574	+	drawsquare(False, c->isfloating, False, dc.sel);
576	575		}
577	576		else
578		-	drawtext(v, NULL, dc.norm, False);
	577	+	drawtext(NULL, dc.norm, False);
579	578		}
580	579		XCopyArea(dpy, dc.drawable, v->barwin, dc.gc, 0, 0, v->w, bh, 0, 0);
581	580		XSync(dpy, False);
582	581		}
583	582
584	583		void
585		-	drawsquare(View *v, Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]) {
	584	+	drawsquare(Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]) {
586	585		int x;
587	586		XGCValues gcv;
588	587		XRectangle r = { dc.x, dc.y, dc.w, dc.h };

603	602		}
604	603
605	604		void
606		-	drawtext(View v, const char text, unsigned long col[ColLast], Bool invert) {
	605	+	drawtext(const char *text, unsigned long col[ColLast], Bool invert) {
607	606		int x, y, w, h;
608	607		unsigned int len, olen;
609	608		XRectangle r = { dc.x, dc.y, dc.w, dc.h };

680	679		View *v;
681	680		XExposeEvent *ev = &e->xexpose;
682	681
683		-	if(ev->count == 0 && (v = getviewbar(ev->window)))
	682	+	if(ev->count == 0 && ((v = getviewbar(ev->window))))
684	683		drawbar(v);
685	684		}
686	685

698	697		focus(Client *c) {
699	698		View *v = selview;
700	699		if(c)
701		-	selview = getview(c);
	700	+	selview = c->view;
702	701		else
703	702		selview = viewat();
704	703		if(selview != v)
705	704		drawbar(v);
706	705		if(!c \|\| (c && !isvisible(c)))
707		-	for(c = stack; c && (!isvisible(c) \|\| getview(c) != selview); c = c->snext);
	706	+	for(c = stack; c && (!isvisible(c) \|\| c->view != selview); c = c->snext);
708	707		if(sel && sel != c) {
709	708		grabbuttons(sel, False);
710	709		XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);

718	717		if(c) {
719	718		XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
720	719		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
721		-	selview = getview(c);
	720	+	selview = c->view;
722	721		}
723	722		else
724	723		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);

744	743		for(c = clients; c && !isvisible(c); c = c->next);
745	744		if(c) {
746	745		focus(c);
747		-	restack(getview(c));
	746	+	restack(c->view);
748	747		}
749	748		}
750	749

761	760		}
762	761		if(c) {
763	762		focus(c);
764		-	restack(getview(c));
	763	+	restack(c->view);
765	764		}
766	765		}
767	766

793	792		return NULL;
794	793		}
795	794
796		-	View *
797		-	getview(Client *c) {
798		-	unsigned int i;
799		-
800		-	for(i = 0; i < LENGTH(tags); i++)
801		-	if(c->tags[i])
802		-	return &views[c->tags[i] - 1];
803		-	return &views[0]; /* fallback */
804		-	}
805		-
806	795		long
807	796		getstate(Window w) {
808	797		int format, status;

1058	1047
1059	1048		applyrules(c);
1060	1049
1061		-	v = getview(c);
	1050	+	v = c->view;
1062	1051
1063	1052		c->x = wa->x + v->x;
1064	1053		c->y = wa->y + v->y;

1137	1126
1138	1127		ocx = nx = c->x;
1139	1128		ocy = ny = c->y;
1140		-	v = getview(c);
	1129	+	v = c->view;
1141	1130		if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
1142	1131		None, cursor[CurMove], CurrentTime) != GrabSuccess)
1143	1132		return;

1176	1165
1177	1166		Client *
1178	1167		nexttiled(Client c, View v) {
1179		-	for(; c && (c->isfloating \|\| getview(c) != v \|\| !isvisible(c)); c = c->next);
	1168	+	for(; c && (c->isfloating \|\| c->view != v \|\| !isvisible(c)); c = c->next);
1180	1169		return c;
1181	1170		}
1182	1171

1201	1190		break;
1202	1191		case XA_WM_HINTS:
1203	1192		updatewmhints(c);
1204		-	drawbar(getview(c));
	1193	+	drawbar(c->view);
1205	1194		break;
1206	1195		}
1207	1196		if(ev->atom == XA_WM_NAME \|\| ev->atom == netatom[NetWMName]) {

1234	1223		View *v;
1235	1224		XWindowChanges wc;
1236	1225
1237		-	v = getview(c);
	1226	+	v = c->view;
1238	1227		if(sizehints) {
1239	1228		/* set minimum possible */
1240	1229		if (w < 1)

1305	1294
1306	1295		ocx = c->x;
1307	1296		ocy = c->y;
1308		-	v = getview(c);
	1297	+	v = c->view;
1309	1298		if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
1310	1299		None, cursor[CurResize], CurrentTime) != GrabSuccess)
1311	1300		return;

1484	1473		if(sel)
1485	1474		arrange();
1486	1475		else
1487		-	drawbar(v);
	1476	+	drawbar(selview);
1488	1477		}
1489	1478
1490	1479		void
1491	1480		setmwfact(const char *arg) {
1492	1481		double delta;
1493		-
1494	1482		View *v = selview;
1495	1483
1496	1484		if(!domwfact)

1537	1525		isxinerama = True;
1538	1526		nviews = 2; /* aim Xinerama */
1539	1527		#endif
1540		-	selview = views = emallocz(nviews * sizeof(View));
	1528	+	views = emallocz(nviews * sizeof(View));
1541	1529
1542	1530		screen = DefaultScreen(dpy);
1543	1531		root = RootWindow(dpy, screen);

1627	1615		if(info)
1628	1616		XFree(info);
1629	1617
	1618	+	selview = viewat();
	1619	+
1630	1620		/* grab keys */
1631	1621		grabkeys();
1632		-
1633		-	selview = &views[0];
1634	1622		}
1635	1623
1636	1624		void

1990	1978
1991	1979		if(!sel \|\| !dozoom \|\| sel->isfloating)
1992	1980		return;
1993		-	if(c == nexttiled(clients, getview(c)))
1994		-	if(!(c = nexttiled(c->next, getview(c))))
	1981	+	if(c == nexttiled(clients, c->view))
	1982	+	if(!(c = nexttiled(c->next, c->view)))
1995	1983		return;
1996	1984		detach(c);
1997	1985		attach(c);