dwm: comparison dwm.c

equal deleted inserted replaced

-:a6f93a5772b2
+:c4b9f97e4bd7
-//#define XINULATOR /* debug, simulates dual head */
 /* See LICENSE file for copyright and license details.
 *
 * dynamic window manager is designed like any other X client as well. It is
 * driven through handling X events. In contrast to other X clients, a window
 * manager selects for SubstructureRedirectMask on the root window, to receive
 static void enternotify(XEvent *e);
 static void expose(XEvent *e);
 static void focus(Client *c);
 static void focusin(XEvent *e);
 static void focusstack(const Arg *arg);
-static Client *getclient(Window w);
 static unsigned long getcolor(const char *colstr);
-static Monitor *getmon(Window w);
-static Monitor *getmonn(unsigned int n);
-static Monitor *getmonxy(int x, int y);
 static Bool getrootpointer(int *x, int *y);
 static long getstate(Window w);
 static Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
 static void grabbuttons(Client *c, Bool focused);
 static void grabkeys(void);
+static Monitor *idxtomon(unsigned int n);
 static void initfont(const char *fontstr);
 static Bool isprotodel(Client *c);
 static void keypress(XEvent *e);
 static void killclient(const Arg *arg);
 static void manage(Window w, XWindowAttributes *wa);
 static void mappingnotify(XEvent *e);
 static void maprequest(XEvent *e);
 static void monocle(Monitor *m);
 static void movemouse(const Arg *arg);
 static Client *nexttiled(Client *c);
+static Monitor *pointertomon(int x, int y);
 static void propertynotify(XEvent *e);
 static void quit(const Arg *arg);
 static void resize(Client *c, int x, int y, int w, int h);
 static void resizemouse(const Arg *arg);
 static void restack(Monitor *m);
 static void updatesizehints(Client *c);
 static void updatestatus(void);
 static void updatetitle(Client *c);
 static void updatewmhints(Client *c);
 static void view(const Arg *arg);
+static Client *wintoclient(Window w);
+static Monitor *wintomon(Window w);
 static int xerror(Display *dpy, XErrorEvent *ee);
 static int xerrordummy(Display *dpy, XErrorEvent *ee);
 static int xerrorstart(Display *dpy, XErrorEvent *ee);
 static void zoom(const Arg *arg);
 #ifdef XINERAMA
 	Monitor *m;
 	XButtonPressedEvent *ev = &e->xbutton;
 	click = ClkRootWin;
 	/* focus monitor if necessary */
-	if((m = getmon(ev->window)) && m != selmon) {
+	if((m = wintomon(ev->window)) && m != selmon) {
 		unfocus(selmon->sel);
 		selmon = m;
 		focus(NULL);
 	}
 	if(ev->window == selmon->barwin && ev->x >= selmon->btx) {
 		else if(ev->x > selmon->wx + selmon->ww - TEXTW(stext))
 			click = ClkStatusText;
 		else
 			click = ClkWinTitle;
 	}
-	else if((c = getclient(ev->window))) {
+	else if((c = wintoclient(ev->window))) {
 		focus(c);
 		click = ClkClientWin;
 	}
 	for(i = 0; i < LENGTH(buttons); i++)
 	Layout foo = { "", NULL };
 	Monitor *m;
 	view(&a);
 	lt[selmon->sellt] = &foo;
-	/* TODO: consider simplifying cleanup code of the stack, perhaps do that in cleanmons() ? */
 	for(m = mons; m; m = m->next)
 		while(m->stack)
 			unmanage(m->stack);
 	if(dc.font.set)
 		XFreeFontSet(dpy, dc.font.set);
 	Client *c;
 	Monitor *m;
 	XConfigureRequestEvent *ev = &e->xconfigurerequest;
 	XWindowChanges wc;
-	if((c = getclient(ev->window))) {
+	if((c = wintoclient(ev->window))) {
 		if(ev->value_mask & CWBorderWidth)
 			c->bw = ev->border_width;
 		else if(c->isfloating || !lt[selmon->sellt]->arrange) {
 			m = c->mon;
 			if(ev->value_mask & CWX)
 void
 destroynotify(XEvent *e) {
 	Client *c;
 	XDestroyWindowEvent *ev = &e->xdestroywindow;
-	if((c = getclient(ev->window)))
+	if((c = wintoclient(ev->window)))
 		unmanage(c);
 }
 void
 detach(Client *c) {
 detachstack(Client *c) {
 	Client **tc;
 	for(tc = &c->mon->stack; *tc && *tc != c; tc = &(*tc)->snext);
 	*tc = c->snext;
+	if(c == c->mon->sel) {
+		for(*tc = c->mon->stack; *tc && !ISVISIBLE((*tc)); *tc = (*tc)->snext);
+		c->mon->sel = *tc;
+	}
 }
 void
 die(const char *errstr, ...) {
 	va_list ap;
 	Monitor *m;
 	XCrossingEvent *ev = &e->xcrossing;
 	if((ev->mode != NotifyNormal || ev->detail == NotifyInferior) && ev->window != root)
 		return;
-	if((m = getmon(ev->window)) && m != selmon) {
+	if((m = wintomon(ev->window)) && m != selmon) {
 		unfocus(selmon->sel);
 		selmon = m;
 	}
-	if((c = getclient(ev->window)))
+	if((c = wintoclient(ev->window)))
 		focus(c);
 	else
 		focus(NULL);
 }
 void
 expose(XEvent *e) {
 	Monitor *m;
 	XExposeEvent *ev = &e->xexpose;
-	if(ev->count == 0 && (m = getmon(ev->window)))
+	if(ev->count == 0 && (m = wintomon(ev->window)))
 		drawbar(m);
 }
 void
 focus(Client *c) {
 #ifdef XINERAMA
 void
 focusmon(const Arg *arg) {
 	Monitor *m;
-	if(!(m = getmonn(arg->ui)) || m == selmon)
+	if(!(m = idxtomon(arg->ui)) || m == selmon)
 		return;
 	unfocus(selmon->sel);
 	selmon = m;
 	focus(NULL);
 }
 		focus(c);
 		restack(selmon);
 	}
 }
-Client *
-getclient(Window w) {
-	Client *c;
-	Monitor *m;
-	for(m = mons; m; m = m->next)
-		for(c = m->clients; c; c = c->next)
-			if(c->win == w)
-				return c;
-	return NULL;
-}
 unsigned long
 getcolor(const char *colstr) {
 	Colormap cmap = DefaultColormap(dpy, screen);
 	XColor color;
 	if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
 		die("error, cannot allocate color '%s'\n", colstr);
 	return color.pixel;
-}
-Monitor *
-getmon(Window w) {
-	int x, y;
-	Client *c;
-	Monitor *m;
-	if(w == root && getrootpointer(&x, &y))
-		return getmonxy(x, y);
-	for(m = mons; m; m = m->next)
-		if(w == m->barwin)
-			return m;
-	if((c = getclient(w)))
-		return c->mon;
-	return mons;
-}
-Monitor *
-getmonn(unsigned int n) {
-	unsigned int i;
-	Monitor *m;
-	for(m = mons, i = 0; m && i != n; m = m->next, i++);
-	return m;
-}
-Monitor *
-getmonxy(int x, int y) {
-	Monitor *m;
-	for(m = mons; m; m = m->next)
-		if(INRECT(x, y, m->wx, m->wy, m->ww, m->wh))
-			return m;
-	return mons;
 }
 Bool
 getrootpointer(int *x, int *y) {
 	int di;
 						 True, GrabModeAsync, GrabModeAsync);
 		}
 	}
 }
+Monitor *
+idxtomon(unsigned int n) {
+	unsigned int i;
+	Monitor *m;
+	for(m = mons, i = 0; m && i != n; m = m->next, i++);
+	return m;
+}
 void
 initfont(const char *fontstr) {
 	char *def, **missing;
 	int i, n;
 	updatesizehints(c);
 	XSelectInput(dpy, w, EnterWindowMask|FocusChangeMask|PropertyChangeMask|StructureNotifyMask);
 	grabbuttons(c, False);
 	updatetitle(c);
 	if(XGetTransientForHint(dpy, w, &trans))
-		t = getclient(trans);
+		t = wintoclient(trans);
 	if(t)
 		c->tags = t->tags;
 	else
 		applyrules(c);
 	if(!c->isfloating)
 	if(!XGetWindowAttributes(dpy, ev->window, &wa))
 		return;
 	if(wa.override_redirect)
 		return;
-	if(!getclient(ev->window))
+	if(!wintoclient(ev->window))
 		manage(ev->window, &wa);
 }
 void
 monocle(Monitor *m) {
 			break;
 		}
 	}
 	while(ev.type != ButtonRelease);
 	XUngrabPointer(dpy, CurrentTime);
-	if((m = getmonxy(c->x + c->w / 2, c->y + c->h / 2)) != selmon) {
+	if((m = pointertomon(c->x + c->w / 2, c->y + c->h / 2)) != selmon) {
 		sendmon(c, m);
 		selmon = m;
 		focus(NULL);
 	}
 }
 nexttiled(Client *c) {
 	for(; c && (c->isfloating || !ISVISIBLE(c)); c = c->next);
 	return c;
 }
+Monitor *
+pointertomon(int x, int y) {
+	Monitor *m;
+	for(m = mons; m; m = m->next)
+		if(INRECT(x, y, m->wx, m->wy, m->ww, m->wh))
+			return m;
+	return mons;
+}
 void
 propertynotify(XEvent *e) {
 	Client *c;
 	Window trans;
 	XPropertyEvent *ev = &e->xproperty;
 	if((ev->window == root) && (ev->atom == XA_WM_NAME))
 		updatestatus();
 	else if(ev->state == PropertyDelete)
 		return; /* ignore */
-	else if((c = getclient(ev->window))) {
+	else if((c = wintoclient(ev->window))) {
 		switch (ev->atom) {
 		default: break;
 		case XA_WM_TRANSIENT_FOR:
 			XGetTransientForHint(dpy, c->win, &trans);
-			if(!c->isfloating && (c->isfloating = (getclient(trans) != NULL)))
+			if(!c->isfloating && (c->isfloating = (wintoclient(trans) != NULL)))
 				arrange();
 			break;
 		case XA_WM_NORMAL_HINTS:
 			updatesizehints(c);
 			break;
 	}
 	while(ev.type != ButtonRelease);
 	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->bw - 1, c->h + c->bw - 1);
 	XUngrabPointer(dpy, CurrentTime);
 	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
-	if((m = getmonxy(c->x + c->w / 2, c->y + c->h / 2)) != selmon) {
+	if((m = pointertomon(c->x + c->w / 2, c->y + c->h / 2)) != selmon) {
 		sendmon(c, m);
 		selmon = m;
 		focus(NULL);
 	}
 }
 #ifdef XINERAMA
 void
 tagmon(const Arg *arg) {
 	Monitor *m;
-	if(!selmon->sel || !(m = getmonn(arg->ui)))
+	if(!selmon->sel || !(m = idxtomon(arg->ui)))
 		return;
 	sendmon(selmon->sel, m);
 }
 #endif /* XINERAMA */
 	XGrabServer(dpy);
 	XSetErrorHandler(xerrordummy);
 	XConfigureWindow(dpy, c->win, CWBorderWidth, &wc); /* restore border */
 	detach(c);
 	detachstack(c);
-	if(c->mon->sel == c) {
-		/* TODO: consider separate the next code into a function or into detachstack? */
-		Client *tc;
-		for(tc = c->mon->stack; tc && !ISVISIBLE(tc); tc = tc->snext);
-		c->mon->sel = tc;
-		focus(NULL);
-	}
 	XUngrabButton(dpy, AnyButton, AnyModifier, c->win);
 	setclientstate(c, WithdrawnState);
 	free(c);
 	XSync(dpy, False);
 	XSetErrorHandler(xerror);
 	XUngrabServer(dpy);
+	focus(NULL);
 	arrange();
 }
 void
 unmapnotify(XEvent *e) {
 	Client *c;
 	XUnmapEvent *ev = &e->xunmap;
-	if((c = getclient(ev->window)))
+	if((c = wintoclient(ev->window)))
 		unmanage(c);
 }
 void
 updatebars(void) {
 updategeom(void) {
 	int i, n = 1;
 	Client *c;
 	Monitor *newmons = NULL, *m, *tm;
-#ifdef XINULATOR
+#ifdef XINERAMA
-	n = 2;
-#elif defined(XINERAMA)
 	XineramaScreenInfo *info = NULL;
 	if(XineramaIsActive(dpy))
 		info = XineramaQueryScreens(dpy, &n);
-#endif
+#endif /* XINERAMA */
 	/* allocate monitor(s) for the new geometry setup */
 	for(i = 0; i < n; i++) {
 		m = (Monitor *)malloc(sizeof(Monitor));
 		m->next = newmons;
 		newmons = m;
 	}
 	/* initialise monitor(s) */
-#ifdef XINULATOR
+#ifdef XINERAMA
-	if(1) {
-		m = newmons;
-		m->screen_number = 0;
-		m->wx = sx;
-		m->my = m->wy = sy;
-		m->ww = sw;
-		m->mh = m->wh = sh / 2;
-		m = newmons->next;
-		m->screen_number = 1;
-		m->wx = sx;
-		m->my = m->wy = sy + sh / 2;
-		m->ww = sw;
-		m->mh = m->wh = sh / 2;
-	}
-	else
-#elif defined(XINERAMA)
 	if(XineramaIsActive(dpy)) {
 		for(i = 0, m = newmons; m; m = m->next, i++) {
 			m->screen_number = info[i].screen_number;
 			m->mx = m->wx = info[i].x_org;
 			m->my = m->wy = info[i].y_org;
 			m->mh = m->wh = info[i].height;
 		}
 		XFree(info);
 	}
 	else
-#endif
+#endif /* XINERAMA */
 	/* default monitor setup */
 	{
 		m->screen_number = 0;
 		m->wx = sx;
 		m->my = m->wy = sy;
 		m->mh = m->wh = sh;
 	}
 	/* bar geometry setup */
 	for(m = newmons; m; m = m->next) {
-		/* TODO: consider removing the following values from config.h */
+		m->sel = m->stack = m->clients = NULL;
-		m->clients = NULL;
-		m->sel = NULL;
-		m->stack = NULL;
 		m->seltags = 0;
 		m->sellt = 0;
 		m->tagset[0] = m->tagset[1] = 1;
 		m->mfact = mfact;
-		m->showbar = showbar;
+		m->showbar = SHOWBAR;
-		m->topbar = topbar;
+		m->topbar = TOPBAR;
 		updatebarpos(m);
 	}
 	/* reassign left over clients of disappeared monitors */
 	for(tm = mons; tm; tm = tm->next)
 		}
 	/* select focused monitor */
 	cleanupmons();
 	mons = newmons;
-	selmon = getmon(root);
+	selmon = wintomon(root);
 }
 void
 updatenumlockmask(void) {
 	unsigned int i, j;
 		return;
 	selmon->seltags ^= 1; /* toggle sel tagset */
 	if(arg->ui & TAGMASK)
 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
 	arrange();
+}
+Client *
+wintoclient(Window w) {
+	Client *c;
+	Monitor *m;
+	for(m = mons; m; m = m->next)
+		for(c = m->clients; c; c = c->next)
+			if(c->win == w)
+				return c;
+	return NULL;
+}
+Monitor *
+wintomon(Window w) {
+	int x, y;
+	Client *c;
+	Monitor *m;
+	if(w == root && getrootpointer(&x, &y))
+		return pointertomon(x, y);
+	for(m = mons; m; m = m->next)
+		if(w == m->barwin)
+			return m;
+	if((c = wintoclient(w)))
+		return c->mon;
+	return mons;
 }
 /* There's no way to check accesses to destroyed windows, thus those cases are
 * ignored (especially on UnmapNotify's).  Other types of errors call Xlibs
 * default error handler, which may call exit.  */

changeset 1430	c4b9f97e4bd7
parent 1429	a6f93a5772b2
child 1431	5b2240f2d21f