git.stevedylan.dev

removed Monitor->dc, unnecessary c2737b7b

Anselm R Garbe · 2008-02-18 17:08 1 file(s) · +124 −123

dwm.c +124 −123

} Regs;

typedef struct {
	int screen;
	int monitor;
	Window barwin;
	int sx, sy, sw, sh, wax, way, wah, waw;
	DC dc;
	Bool *seltags;
	Bool *prevtags;
	Layout *layout;

void focusnext(const char *arg);
void focusprev(const char *arg);
Client *getclient(Window w);
unsigned long getcolor(const char *colstr, int screen);
unsigned long getcolor(const char *colstr);
long getstate(Window w);
Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
void grabbuttons(Client *c, Bool focused);
void grabkeys(void);
unsigned int idxoftag(const char *tag);
void initfont(Monitor*, const char *fontstr);
void initfont(const char *fontstr);
Bool isoccupied(unsigned int monitor, unsigned int t);
Bool isprotodel(Client *c);
Bool isurgent(unsigned int monitor, unsigned int t);

void setup(void);
void spawn(const char *arg);
void tag(const char *arg);
unsigned int textnw(Monitor*, const char *text, unsigned int len);
unsigned int textw(Monitor*, const char *text);
unsigned int textnw(const char *text, unsigned int len);
unsigned int textw(const char *text);
void tile(void);
void togglebar(const char *arg);
void togglefloating(const char *arg);

char stext[256];
int mcount = 1;
int selmonitor = 0;
int screen;
int (*xerrorxlib)(Display *, XErrorEvent *);
unsigned int bh, bpos;
unsigned int blw = 0;

	if(ev->window == m->barwin) {
		x = 0;
		for(i = 0; i < LENGTH(tags); i++) {
			x += textw(m, tags[i]);
			x += textw(tags[i]);
			if(ev->x < x) {
				if(ev->button == Button1) {
					if(ev->state & MODKEY)

		unban(stack);
		unmanage(stack);
	}
	for(i = 0; i < mcount; i++) {
		Monitor *m = &monitors[i];
		if(m->dc.font.set)
			XFreeFontSet(dpy, m->dc.font.set);
		else
			XFreeFont(dpy, m->dc.font.xfont);
		XUngrabKey(dpy, AnyKey, AnyModifier, root);
		XFreePixmap(dpy, m->dc.drawable);
		XFreeGC(dpy, m->dc.gc);
		XDestroyWindow(dpy, m->barwin);
		XFreeCursor(dpy, cursor[CurNormal]);
		XFreeCursor(dpy, cursor[CurResize]);
		XFreeCursor(dpy, cursor[CurMove]);
		XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
		XSync(dpy, False);
	}
	if(dc.font.set)
		XFreeFontSet(dpy, dc.font.set);
	else
		XFreeFont(dpy, dc.font.xfont);

	XUngrabKey(dpy, AnyKey, AnyModifier, root);
	XFreePixmap(dpy, dc.drawable);
	XFreeGC(dpy, dc.gc);
	XFreeCursor(dpy, cursor[CurNormal]);
	XFreeCursor(dpy, cursor[CurResize]);
	XFreeCursor(dpy, cursor[CurMove]);
	for(i = 0; i < mcount; i++)
		XDestroyWindow(dpy, monitors[i].barwin);
	XSync(dpy, False);
	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
}

void

	Monitor *m = &monitors[selmonitor];

	if(ev->window == root && (ev->width != m->sw || ev->height != m->sh)) {
		/* TODO -- update Xinerama dimensions here */
		m->sw = ev->width;
		m->sh = ev->height;
		XFreePixmap(dpy, dc.drawable);
		dc.drawable = XCreatePixmap(dpy, root, m->sw, bh, DefaultDepth(dpy, m->screen));
		dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(root, screen), bh, DefaultDepth(dpy, screen));
		XResizeWindow(dpy, m->barwin, m->sw, bh);
		updatebarpos(m);
		arrange();


	for(i = 0; i < mcount; i++) {
		Monitor *m = &monitors[i];
		m->dc.x = 0;
		dc.x = 0;
		for(c = stack; c && !isvisible(c, i); c = c->snext);
		fprintf(stderr, "m%d %s\n", i, c ? c->name : "NIL");
		for(j = 0; j < LENGTH(tags); j++) {
			m->dc.w = textw(m, tags[j]);
			dc.w = textw(tags[j]);
			if(m->seltags[j]) {
				drawtext(m, tags[j], m->dc.sel, isurgent(i, j));
				drawtext(m, tags[j], dc.sel, isurgent(i, j));
				drawsquare(m, c && c->tags[j] && c->monitor == i,
						isoccupied(i, j), isurgent(i, j), m->dc.sel);
						isoccupied(i, j), isurgent(i, j), dc.sel);
			}
			else {
				drawtext(m, tags[j], m->dc.norm, isurgent(i, j));
				drawtext(m, tags[j], dc.norm, isurgent(i, j));
				drawsquare(m, c && c->tags[j] && c->monitor == i,
						isoccupied(i, j), isurgent(i, j), m->dc.norm);
						isoccupied(i, j), isurgent(i, j), dc.norm);
			}
			m->dc.x += m->dc.w;
			dc.x += dc.w;
		}
		m->dc.w = blw;
		drawtext(m, m->layout->symbol, m->dc.norm, False);
		x = m->dc.x + m->dc.w;
		dc.w = blw;
		drawtext(m, m->layout->symbol, dc.norm, False);
		x = dc.x + dc.w;
		if(i == selmonitor) {
			m->dc.w = textw(m, stext);
			m->dc.x = m->sw - m->dc.w;
			if(m->dc.x < x) {
				m->dc.x = x;
				m->dc.w = m->sw - x;
			dc.w = textw(stext);
			dc.x = m->sw - dc.w;
			if(dc.x < x) {
				dc.x = x;
				dc.w = m->sw - x;
			}
			drawtext(m, stext, m->dc.norm, False);
			drawtext(m, stext, dc.norm, False);
		}
		else
			m->dc.x = m->sw;
		if((m->dc.w = m->dc.x - x) > bh) {
			m->dc.x = x;
			dc.x = m->sw;
		if((dc.w = dc.x - x) > bh) {
			dc.x = x;
			if(c) {
				drawtext(m, c->name, m->dc.sel, False);
				drawsquare(m, False, c->isfloating, False, m->dc.sel);
				drawtext(m, c->name, dc.sel, False);
				drawsquare(m, False, c->isfloating, False, dc.sel);
			}
			else
				drawtext(m, NULL, m->dc.norm, False);
				drawtext(m, NULL, dc.norm, False);
		}
		XCopyArea(dpy, m->dc.drawable, m->barwin, m->dc.gc, 0, 0, m->sw, bh, 0, 0);
		XCopyArea(dpy, dc.drawable, m->barwin, dc.gc, 0, 0, m->sw, bh, 0, 0);
		XSync(dpy, False);
	}
}

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

	gcv.foreground = col[invert ? ColBG : ColFG];
	XChangeGC(dpy, m->dc.gc, GCForeground, &gcv);
	x = (m->dc.font.ascent + m->dc.font.descent + 2) / 4;
	r.x = m->dc.x + 1;
	r.y = m->dc.y + 1;
	XChangeGC(dpy, dc.gc, GCForeground, &gcv);
	x = (dc.font.ascent + dc.font.descent + 2) / 4;
	r.x = dc.x + 1;
	r.y = dc.y + 1;
	if(filled) {
		r.width = r.height = x + 1;
		XFillRectangles(dpy, m->dc.drawable, m->dc.gc, &r, 1);
		XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
	}
	else if(empty) {
		r.width = r.height = x;
		XDrawRectangles(dpy, m->dc.drawable, m->dc.gc, &r, 1);
		XDrawRectangles(dpy, dc.drawable, dc.gc, &r, 1);
	}
}


	int x, y, w, h;
	static char buf[256];
	unsigned int len, olen;
	XRectangle r = { m->dc.x, m->dc.y, m->dc.w, m->dc.h };
	XRectangle r = { dc.x, dc.y, dc.w, dc.h };

	XSetForeground(dpy, m->dc.gc, col[invert ? ColFG : ColBG]);
	XFillRectangles(dpy, m->dc.drawable, m->dc.gc, &r, 1);
	XSetForeground(dpy, dc.gc, col[invert ? ColFG : ColBG]);
	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
	if(!text)
		return;
	w = 0;

		len = sizeof buf - 1;
	memcpy(buf, text, len);
	buf[len] = 0;
	h = m->dc.font.ascent + m->dc.font.descent;
	y = m->dc.y + (m->dc.h / 2) - (h / 2) + m->dc.font.ascent;
	x = m->dc.x + (h / 2);
	h = dc.font.ascent + dc.font.descent;
	y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;
	x = dc.x + (h / 2);
	/* shorten text if necessary */
	while(len && (w = textnw(m, buf, len)) > m->dc.w - h)
	while(len && (w = textnw(buf, len)) > dc.w - h)
		buf[--len] = 0;
	if(len < olen) {
		if(len > 1)

		if(len > 3)
			buf[len - 3] = '.';
	}
	if(w > m->dc.w)
	if(w > dc.w)
		return; /* too long */
	XSetForeground(dpy, m->dc.gc, col[invert ? ColBG : ColFG]);
	if(m->dc.font.set)
		XmbDrawString(dpy, m->dc.drawable, m->dc.font.set, m->dc.gc, x, y, buf, len);
	XSetForeground(dpy, dc.gc, col[invert ? ColBG : ColFG]);
	if(dc.font.set)
		XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);
	else
		XDrawString(dpy, m->dc.drawable, m->dc.gc, x, y, buf, len);
		XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);
}

void *

		for(c = stack; c && !isvisible(c, c->monitor); c = c->snext);
	if(sel && sel != c) {
		grabbuttons(sel, False);
		XSetWindowBorder(dpy, sel->win, monitors[sel->monitor].dc.norm[ColBorder]);
		XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);
	}
	if(c) {
		detachstack(c);

	sel = c;
	drawbar();
	if(c) {
		XSetWindowBorder(dpy, c->win, m->dc.sel[ColBorder]);
		XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
		selmonitor = c->monitor;
	}

}

unsigned long
getcolor(const char *colstr, int screen) {
getcolor(const char *colstr) {
	Colormap cmap = DefaultColormap(dpy, screen);
	XColor color;


}

void
initfont(Monitor *m, const char *fontstr) {
initfont(const char *fontstr) {
	char *def, **missing;
	int i, n;

	missing = NULL;
	if(m->dc.font.set)
		XFreeFontSet(dpy, m->dc.font.set);
	m->dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
	if(dc.font.set)
		XFreeFontSet(dpy, dc.font.set);
	dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
	if(missing) {
		while(n--)
			fprintf(stderr, "dwm: missing fontset: %s\n", missing[n]);
		XFreeStringList(missing);
	}
	if(m->dc.font.set) {
	if(dc.font.set) {
		XFontSetExtents *font_extents;
		XFontStruct **xfonts;
		char **font_names;
		m->dc.font.ascent = m->dc.font.descent = 0;
		font_extents = XExtentsOfFontSet(m->dc.font.set);
		n = XFontsOfFontSet(m->dc.font.set, &xfonts, &font_names);
		for(i = 0, m->dc.font.ascent = 0, m->dc.font.descent = 0; i < n; i++) {
			if(m->dc.font.ascent < (*xfonts)->ascent)
				m->dc.font.ascent = (*xfonts)->ascent;
			if(m->dc.font.descent < (*xfonts)->descent)
				m->dc.font.descent = (*xfonts)->descent;
		dc.font.ascent = dc.font.descent = 0;
		font_extents = XExtentsOfFontSet(dc.font.set);
		n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);
		for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {
			if(dc.font.ascent < (*xfonts)->ascent)
				dc.font.ascent = (*xfonts)->ascent;
			if(dc.font.descent < (*xfonts)->descent)
				dc.font.descent = (*xfonts)->descent;
			xfonts++;
		}
	}
	else {
		if(m->dc.font.xfont)
			XFreeFont(dpy, m->dc.font.xfont);
		m->dc.font.xfont = NULL;
		if(!(m->dc.font.xfont = XLoadQueryFont(dpy, fontstr))
		&& !(m->dc.font.xfont = XLoadQueryFont(dpy, "fixed")))
		if(dc.font.xfont)
			XFreeFont(dpy, dc.font.xfont);
		dc.font.xfont = NULL;
		if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr))
		&& !(dc.font.xfont = XLoadQueryFont(dpy, "fixed")))
			eprint("error, cannot load font: '%s'\n", fontstr);
		m->dc.font.ascent = m->dc.font.xfont->ascent;
		m->dc.font.descent = m->dc.font.xfont->descent;
		dc.font.ascent = dc.font.xfont->ascent;
		dc.font.descent = dc.font.xfont->descent;
	}
	m->dc.font.height = m->dc.font.ascent + m->dc.font.descent;
	dc.font.height = dc.font.ascent + dc.font.descent;
}

Bool

	}
	wc.border_width = c->border;
	XConfigureWindow(dpy, w, CWBorderWidth, &wc);
	XSetWindowBorder(dpy, w, m->dc.norm[ColBorder]);
	XSetWindowBorder(dpy, w, dc.norm[ColBorder]);
	configure(c); /* propagates border_width, if size doesn't change */
	updatesizehints(c);
	XSelectInput(dpy, w, EnterWindowMask | FocusChangeMask | PropertyChangeMask | StructureNotifyMask);


void
setup(void) {
	unsigned int i, j, k;
	unsigned int i;
	Monitor *m;
	XSetWindowAttributes wa;
	XineramaScreenInfo *info = NULL;

		info = XineramaQueryScreens(dpy, &mcount);
	monitors = emallocz(mcount * sizeof(Monitor));

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

	/* init appearance */
	dc.norm[ColBorder] = getcolor(NORMBORDERCOLOR);
	dc.norm[ColBG] = getcolor(NORMBGCOLOR);
	dc.norm[ColFG] = getcolor(NORMFGCOLOR);
	dc.sel[ColBorder] = getcolor(SELBORDERCOLOR);
	dc.sel[ColBG] = getcolor(SELBGCOLOR);
	dc.sel[ColFG] = getcolor(SELFGCOLOR);
	initfont(FONT);
	dc.h = bh = dc.font.height + 2;
	dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(dpy, screen), bh, DefaultDepth(dpy, screen));
	dc.gc = XCreateGC(dpy, root, 0, 0);
	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
	if(!dc.font.set)
		XSetFont(dpy, dc.gc, dc.font.xfont->fid);

	for(blw = i = 0; i < LENGTH(layouts); i++) {
		i = textw(layouts[i].symbol);
		if(i > blw)
			blw = i;
	}
	for(i = 0; i < mcount; i++) {
		/* init geometry */
		m = &monitors[i];

		m->screen = isxinerama ? 0 : i;
		m->monitor = i;

		if (mcount != 1 && isxinerama) {
			m->sx = info[i].x_org;

		else {
			m->sx = 0;
			m->sy = 0;
			m->sw = DisplayWidth(dpy, m->screen);
			m->sh = DisplayHeight(dpy, m->screen);
			m->sw = DisplayWidth(dpy, screen);
			m->sh = DisplayHeight(dpy, screen);
		}

		m->seltags = emallocz(sizeof initags);

		memcpy(m->seltags, initags, sizeof initags);
		memcpy(m->prevtags, initags, sizeof initags);

		/* init appearance */
		m->dc.norm[ColBorder] = getcolor(NORMBORDERCOLOR, m->screen);
		m->dc.norm[ColBG] = getcolor(NORMBGCOLOR, m->screen);
		m->dc.norm[ColFG] = getcolor(NORMFGCOLOR, m->screen);
		m->dc.sel[ColBorder] = getcolor(SELBORDERCOLOR, m->screen);
		m->dc.sel[ColBG] = getcolor(SELBGCOLOR, m->screen);
		m->dc.sel[ColFG] = getcolor(SELFGCOLOR, m->screen);
		initfont(m, FONT);
		m->dc.h = bh = m->dc.font.height + 2;

		/* init layouts */
		m->mwfact = MWFACT;
		m->layout = &layouts[0];
		for(blw = k = 0; k < LENGTH(layouts); k++) {
			j = textw(m, layouts[k].symbol);
			if(j > blw)
				blw = j;
		}

		// TODO: bpos per screen?
		bpos = BARPOS;


		/* init bars */
		m->barwin = XCreateWindow(dpy, root, m->sx, m->sy, m->sw, bh, 0,
				DefaultDepth(dpy, m->screen), CopyFromParent, DefaultVisual(dpy, m->screen),
				DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen),
				CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
		XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
		updatebarpos(m);
		XMapRaised(dpy, m->barwin);
		strcpy(stext, "dwm-"VERSION);
		m->dc.drawable = XCreatePixmap(dpy, root, m->sw, bh, DefaultDepth(dpy, m->screen));
		m->dc.gc = XCreateGC(dpy, root, 0, 0);
		XSetLineAttributes(dpy, m->dc.gc, 1, LineSolid, CapButt, JoinMiter);
		if(!m->dc.font.set)
			XSetFont(dpy, m->dc.gc, m->dc.font.xfont->fid);

		/* EWMH support per monitor */
		XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,

}

unsigned int
textnw(Monitor *m, const char *text, unsigned int len) {
textnw(const char *text, unsigned int len) {
	XRectangle r;

	if(m->dc.font.set) {
		XmbTextExtents(m->dc.font.set, text, len, NULL, &r);
	if(dc.font.set) {
		XmbTextExtents(dc.font.set, text, len, NULL, &r);
		return r.width;
	}
	return XTextWidth(m->dc.font.xfont, text, len);
	return XTextWidth(dc.font.xfont, text, len);
}

unsigned int
textw(Monitor *m, const char *text) {
	return textnw(m, text, strlen(text)) + m->dc.font.height;
textw(const char *text) {
	return textnw(text, strlen(text)) + dc.font.height;
}

void

117	117		} Regs;
118	118
119	119		typedef struct {
120		-	int screen;
	120	+	int monitor;
121	121		Window barwin;
122	122		int sx, sy, sw, sh, wax, way, wah, waw;
123		-	DC dc;
124	123		Bool *seltags;
125	124		Bool *prevtags;
126	125		Layout *layout;

156	155		void focusnext(const char *arg);
157	156		void focusprev(const char *arg);
158	157		Client *getclient(Window w);
159		-	unsigned long getcolor(const char *colstr, int screen);
	158	+	unsigned long getcolor(const char *colstr);
160	159		long getstate(Window w);
161	160		Bool gettextprop(Window w, Atom atom, char *text, unsigned int size);
162	161		void grabbuttons(Client *c, Bool focused);
163	162		void grabkeys(void);
164	163		unsigned int idxoftag(const char *tag);
165		-	void initfont(Monitor, const char fontstr);
	164	+	void initfont(const char *fontstr);
166	165		Bool isoccupied(unsigned int monitor, unsigned int t);
167	166		Bool isprotodel(Client *c);
168	167		Bool isurgent(unsigned int monitor, unsigned int t);

188	187		void setup(void);
189	188		void spawn(const char *arg);
190	189		void tag(const char *arg);
191		-	unsigned int textnw(Monitor, const char text, unsigned int len);
192		-	unsigned int textw(Monitor, const char text);
	190	+	unsigned int textnw(const char *text, unsigned int len);
	191	+	unsigned int textw(const char *text);
193	192		void tile(void);
194	193		void togglebar(const char *arg);
195	194		void togglefloating(const char *arg);

216	215		char stext[256];
217	216		int mcount = 1;
218	217		int selmonitor = 0;
	218	+	int screen;
219	219		int (xerrorxlib)(Display , XErrorEvent *);
220	220		unsigned int bh, bpos;
221	221		unsigned int blw = 0;

343	343		if(ev->window == m->barwin) {
344	344		x = 0;
345	345		for(i = 0; i < LENGTH(tags); i++) {
346		-	x += textw(m, tags[i]);
	346	+	x += textw(tags[i]);
347	347		if(ev->x < x) {
348	348		if(ev->button == Button1) {
349	349		if(ev->state & MODKEY)

408	408		unban(stack);
409	409		unmanage(stack);
410	410		}
411		-	for(i = 0; i < mcount; i++) {
412		-	Monitor *m = &monitors[i];
413		-	if(m->dc.font.set)
414		-	XFreeFontSet(dpy, m->dc.font.set);
415		-	else
416		-	XFreeFont(dpy, m->dc.font.xfont);
417		-	XUngrabKey(dpy, AnyKey, AnyModifier, root);
418		-	XFreePixmap(dpy, m->dc.drawable);
419		-	XFreeGC(dpy, m->dc.gc);
420		-	XDestroyWindow(dpy, m->barwin);
421		-	XFreeCursor(dpy, cursor[CurNormal]);
422		-	XFreeCursor(dpy, cursor[CurResize]);
423		-	XFreeCursor(dpy, cursor[CurMove]);
424		-	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
425		-	XSync(dpy, False);
426		-	}
	411	+	if(dc.font.set)
	412	+	XFreeFontSet(dpy, dc.font.set);
	413	+	else
	414	+	XFreeFont(dpy, dc.font.xfont);
	415	+
	416	+	XUngrabKey(dpy, AnyKey, AnyModifier, root);
	417	+	XFreePixmap(dpy, dc.drawable);
	418	+	XFreeGC(dpy, dc.gc);
	419	+	XFreeCursor(dpy, cursor[CurNormal]);
	420	+	XFreeCursor(dpy, cursor[CurResize]);
	421	+	XFreeCursor(dpy, cursor[CurMove]);
	422	+	for(i = 0; i < mcount; i++)
	423	+	XDestroyWindow(dpy, monitors[i].barwin);
	424	+	XSync(dpy, False);
	425	+	XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
427	426		}
428	427
429	428		void

476	475		Monitor *m = &monitors[selmonitor];
477	476
478	477		if(ev->window == root && (ev->width != m->sw \|\| ev->height != m->sh)) {
	478	+	/* TODO -- update Xinerama dimensions here */
479	479		m->sw = ev->width;
480	480		m->sh = ev->height;
481	481		XFreePixmap(dpy, dc.drawable);
482		-	dc.drawable = XCreatePixmap(dpy, root, m->sw, bh, DefaultDepth(dpy, m->screen));
	482	+	dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(root, screen), bh, DefaultDepth(dpy, screen));
483	483		XResizeWindow(dpy, m->barwin, m->sw, bh);
484	484		updatebarpos(m);
485	485		arrange();

566	566
567	567		for(i = 0; i < mcount; i++) {
568	568		Monitor *m = &monitors[i];
569		-	m->dc.x = 0;
	569	+	dc.x = 0;
570	570		for(c = stack; c && !isvisible(c, i); c = c->snext);
571	571		fprintf(stderr, "m%d %s\n", i, c ? c->name : "NIL");
572	572		for(j = 0; j < LENGTH(tags); j++) {
573		-	m->dc.w = textw(m, tags[j]);
	573	+	dc.w = textw(tags[j]);
574	574		if(m->seltags[j]) {
575		-	drawtext(m, tags[j], m->dc.sel, isurgent(i, j));
	575	+	drawtext(m, tags[j], dc.sel, isurgent(i, j));
576	576		drawsquare(m, c && c->tags[j] && c->monitor == i,
577		-	isoccupied(i, j), isurgent(i, j), m->dc.sel);
	577	+	isoccupied(i, j), isurgent(i, j), dc.sel);
578	578		}
579	579		else {
580		-	drawtext(m, tags[j], m->dc.norm, isurgent(i, j));
	580	+	drawtext(m, tags[j], dc.norm, isurgent(i, j));
581	581		drawsquare(m, c && c->tags[j] && c->monitor == i,
582		-	isoccupied(i, j), isurgent(i, j), m->dc.norm);
	582	+	isoccupied(i, j), isurgent(i, j), dc.norm);
583	583		}
584		-	m->dc.x += m->dc.w;
	584	+	dc.x += dc.w;
585	585		}
586		-	m->dc.w = blw;
587		-	drawtext(m, m->layout->symbol, m->dc.norm, False);
588		-	x = m->dc.x + m->dc.w;
	586	+	dc.w = blw;
	587	+	drawtext(m, m->layout->symbol, dc.norm, False);
	588	+	x = dc.x + dc.w;
589	589		if(i == selmonitor) {
590		-	m->dc.w = textw(m, stext);
591		-	m->dc.x = m->sw - m->dc.w;
592		-	if(m->dc.x < x) {
593		-	m->dc.x = x;
594		-	m->dc.w = m->sw - x;
	590	+	dc.w = textw(stext);
	591	+	dc.x = m->sw - dc.w;
	592	+	if(dc.x < x) {
	593	+	dc.x = x;
	594	+	dc.w = m->sw - x;
595	595		}
596		-	drawtext(m, stext, m->dc.norm, False);
	596	+	drawtext(m, stext, dc.norm, False);
597	597		}
598	598		else
599		-	m->dc.x = m->sw;
600		-	if((m->dc.w = m->dc.x - x) > bh) {
601		-	m->dc.x = x;
	599	+	dc.x = m->sw;
	600	+	if((dc.w = dc.x - x) > bh) {
	601	+	dc.x = x;
602	602		if(c) {
603		-	drawtext(m, c->name, m->dc.sel, False);
604		-	drawsquare(m, False, c->isfloating, False, m->dc.sel);
	603	+	drawtext(m, c->name, dc.sel, False);
	604	+	drawsquare(m, False, c->isfloating, False, dc.sel);
605	605		}
606	606		else
607		-	drawtext(m, NULL, m->dc.norm, False);
	607	+	drawtext(m, NULL, dc.norm, False);
608	608		}
609		-	XCopyArea(dpy, m->dc.drawable, m->barwin, m->dc.gc, 0, 0, m->sw, bh, 0, 0);
	609	+	XCopyArea(dpy, dc.drawable, m->barwin, dc.gc, 0, 0, m->sw, bh, 0, 0);
610	610		XSync(dpy, False);
611	611		}
612	612		}

615	615		drawsquare(Monitor *m, Bool filled, Bool empty, Bool invert, unsigned long col[ColLast]) {
616	616		int x;
617	617		XGCValues gcv;
618		-	XRectangle r = { m->dc.x, m->dc.y, m->dc.w, m->dc.h };
	618	+	XRectangle r = { dc.x, dc.y, dc.w, dc.h };
619	619
620	620		gcv.foreground = col[invert ? ColBG : ColFG];
621		-	XChangeGC(dpy, m->dc.gc, GCForeground, &gcv);
622		-	x = (m->dc.font.ascent + m->dc.font.descent + 2) / 4;
623		-	r.x = m->dc.x + 1;
624		-	r.y = m->dc.y + 1;
	621	+	XChangeGC(dpy, dc.gc, GCForeground, &gcv);
	622	+	x = (dc.font.ascent + dc.font.descent + 2) / 4;
	623	+	r.x = dc.x + 1;
	624	+	r.y = dc.y + 1;
625	625		if(filled) {
626	626		r.width = r.height = x + 1;
627		-	XFillRectangles(dpy, m->dc.drawable, m->dc.gc, &r, 1);
	627	+	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
628	628		}
629	629		else if(empty) {
630	630		r.width = r.height = x;
631		-	XDrawRectangles(dpy, m->dc.drawable, m->dc.gc, &r, 1);
	631	+	XDrawRectangles(dpy, dc.drawable, dc.gc, &r, 1);
632	632		}
633	633		}
634	634

637	637		int x, y, w, h;
638	638		static char buf[256];
639	639		unsigned int len, olen;
640		-	XRectangle r = { m->dc.x, m->dc.y, m->dc.w, m->dc.h };
	640	+	XRectangle r = { dc.x, dc.y, dc.w, dc.h };
641	641
642		-	XSetForeground(dpy, m->dc.gc, col[invert ? ColFG : ColBG]);
643		-	XFillRectangles(dpy, m->dc.drawable, m->dc.gc, &r, 1);
	642	+	XSetForeground(dpy, dc.gc, col[invert ? ColFG : ColBG]);
	643	+	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
644	644		if(!text)
645	645		return;
646	646		w = 0;

649	649		len = sizeof buf - 1;
650	650		memcpy(buf, text, len);
651	651		buf[len] = 0;
652		-	h = m->dc.font.ascent + m->dc.font.descent;
653		-	y = m->dc.y + (m->dc.h / 2) - (h / 2) + m->dc.font.ascent;
654		-	x = m->dc.x + (h / 2);
	652	+	h = dc.font.ascent + dc.font.descent;
	653	+	y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;
	654	+	x = dc.x + (h / 2);
655	655		/* shorten text if necessary */
656		-	while(len && (w = textnw(m, buf, len)) > m->dc.w - h)
	656	+	while(len && (w = textnw(buf, len)) > dc.w - h)
657	657		buf[--len] = 0;
658	658		if(len < olen) {
659	659		if(len > 1)

663	663		if(len > 3)
664	664		buf[len - 3] = '.';
665	665		}
666		-	if(w > m->dc.w)
	666	+	if(w > dc.w)
667	667		return; /* too long */
668		-	XSetForeground(dpy, m->dc.gc, col[invert ? ColBG : ColFG]);
669		-	if(m->dc.font.set)
670		-	XmbDrawString(dpy, m->dc.drawable, m->dc.font.set, m->dc.gc, x, y, buf, len);
	668	+	XSetForeground(dpy, dc.gc, col[invert ? ColBG : ColFG]);
	669	+	if(dc.font.set)
	670	+	XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);
671	671		else
672		-	XDrawString(dpy, m->dc.drawable, m->dc.gc, x, y, buf, len);
	672	+	XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);
673	673		}
674	674
675	675		void *

740	740		for(c = stack; c && !isvisible(c, c->monitor); c = c->snext);
741	741		if(sel && sel != c) {
742	742		grabbuttons(sel, False);
743		-	XSetWindowBorder(dpy, sel->win, monitors[sel->monitor].dc.norm[ColBorder]);
	743	+	XSetWindowBorder(dpy, sel->win, dc.norm[ColBorder]);
744	744		}
745	745		if(c) {
746	746		detachstack(c);

750	750		sel = c;
751	751		drawbar();
752	752		if(c) {
753		-	XSetWindowBorder(dpy, c->win, m->dc.sel[ColBorder]);
	753	+	XSetWindowBorder(dpy, c->win, dc.sel[ColBorder]);
754	754		XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
755	755		selmonitor = c->monitor;
756	756		}

809	809		}
810	810
811	811		unsigned long
812		-	getcolor(const char *colstr, int screen) {
	812	+	getcolor(const char *colstr) {
813	813		Colormap cmap = DefaultColormap(dpy, screen);
814	814		XColor color;
815	815

937	937		}
938	938
939	939		void
940		-	initfont(Monitor m, const char fontstr) {
	940	+	initfont(const char *fontstr) {
941	941		char def, *missing;
942	942		int i, n;
943	943
944	944		missing = NULL;
945		-	if(m->dc.font.set)
946		-	XFreeFontSet(dpy, m->dc.font.set);
947		-	m->dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
	945	+	if(dc.font.set)
	946	+	XFreeFontSet(dpy, dc.font.set);
	947	+	dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
948	948		if(missing) {
949	949		while(n--)
950	950		fprintf(stderr, "dwm: missing fontset: %s\n", missing[n]);
951	951		XFreeStringList(missing);
952	952		}
953		-	if(m->dc.font.set) {
	953	+	if(dc.font.set) {
954	954		XFontSetExtents *font_extents;
955	955		XFontStruct **xfonts;
956	956		char **font_names;
957		-	m->dc.font.ascent = m->dc.font.descent = 0;
958		-	font_extents = XExtentsOfFontSet(m->dc.font.set);
959		-	n = XFontsOfFontSet(m->dc.font.set, &xfonts, &font_names);
960		-	for(i = 0, m->dc.font.ascent = 0, m->dc.font.descent = 0; i < n; i++) {
961		-	if(m->dc.font.ascent < (*xfonts)->ascent)
962		-	m->dc.font.ascent = (*xfonts)->ascent;
963		-	if(m->dc.font.descent < (*xfonts)->descent)
964		-	m->dc.font.descent = (*xfonts)->descent;
	957	+	dc.font.ascent = dc.font.descent = 0;
	958	+	font_extents = XExtentsOfFontSet(dc.font.set);
	959	+	n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);
	960	+	for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {
	961	+	if(dc.font.ascent < (*xfonts)->ascent)
	962	+	dc.font.ascent = (*xfonts)->ascent;
	963	+	if(dc.font.descent < (*xfonts)->descent)
	964	+	dc.font.descent = (*xfonts)->descent;
965	965		xfonts++;
966	966		}
967	967		}
968	968		else {
969		-	if(m->dc.font.xfont)
970		-	XFreeFont(dpy, m->dc.font.xfont);
971		-	m->dc.font.xfont = NULL;
972		-	if(!(m->dc.font.xfont = XLoadQueryFont(dpy, fontstr))
973		-	&& !(m->dc.font.xfont = XLoadQueryFont(dpy, "fixed")))
	969	+	if(dc.font.xfont)
	970	+	XFreeFont(dpy, dc.font.xfont);
	971	+	dc.font.xfont = NULL;
	972	+	if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr))
	973	+	&& !(dc.font.xfont = XLoadQueryFont(dpy, "fixed")))
974	974		eprint("error, cannot load font: '%s'\n", fontstr);
975		-	m->dc.font.ascent = m->dc.font.xfont->ascent;
976		-	m->dc.font.descent = m->dc.font.xfont->descent;
	975	+	dc.font.ascent = dc.font.xfont->ascent;
	976	+	dc.font.descent = dc.font.xfont->descent;
977	977		}
978		-	m->dc.font.height = m->dc.font.ascent + m->dc.font.descent;
	978	+	dc.font.height = dc.font.ascent + dc.font.descent;
979	979		}
980	980
981	981		Bool

1101	1101		}
1102	1102		wc.border_width = c->border;
1103	1103		XConfigureWindow(dpy, w, CWBorderWidth, &wc);
1104		-	XSetWindowBorder(dpy, w, m->dc.norm[ColBorder]);
	1104	+	XSetWindowBorder(dpy, w, dc.norm[ColBorder]);
1105	1105		configure(c); /* propagates border_width, if size doesn't change */
1106	1106		updatesizehints(c);
1107	1107		XSelectInput(dpy, w, EnterWindowMask \| FocusChangeMask \| PropertyChangeMask \| StructureNotifyMask);

1549	1549
1550	1550		void
1551	1551		setup(void) {
1552		-	unsigned int i, j, k;
	1552	+	unsigned int i;
1553	1553		Monitor *m;
1554	1554		XSetWindowAttributes wa;
1555	1555		XineramaScreenInfo *info = NULL;

1573	1573		info = XineramaQueryScreens(dpy, &mcount);
1574	1574		monitors = emallocz(mcount * sizeof(Monitor));
1575	1575
1576		-	root = DefaultRootWindow(dpy);
	1576	+	screen = DefaultScreen(dpy);
	1577	+	root = RootWindow(dpy, screen);
	1578	+
	1579	+	/* init appearance */
	1580	+	dc.norm[ColBorder] = getcolor(NORMBORDERCOLOR);
	1581	+	dc.norm[ColBG] = getcolor(NORMBGCOLOR);
	1582	+	dc.norm[ColFG] = getcolor(NORMFGCOLOR);
	1583	+	dc.sel[ColBorder] = getcolor(SELBORDERCOLOR);
	1584	+	dc.sel[ColBG] = getcolor(SELBGCOLOR);
	1585	+	dc.sel[ColFG] = getcolor(SELFGCOLOR);
	1586	+	initfont(FONT);
	1587	+	dc.h = bh = dc.font.height + 2;
	1588	+	dc.drawable = XCreatePixmap(dpy, root, DisplayWidth(dpy, screen), bh, DefaultDepth(dpy, screen));
	1589	+	dc.gc = XCreateGC(dpy, root, 0, 0);
	1590	+	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
	1591	+	if(!dc.font.set)
	1592	+	XSetFont(dpy, dc.gc, dc.font.xfont->fid);
1577	1593
	1594	+	for(blw = i = 0; i < LENGTH(layouts); i++) {
	1595	+	i = textw(layouts[i].symbol);
	1596	+	if(i > blw)
	1597	+	blw = i;
	1598	+	}
1578	1599		for(i = 0; i < mcount; i++) {
1579	1600		/* init geometry */
1580	1601		m = &monitors[i];
1581	1602
1582		-	m->screen = isxinerama ? 0 : i;
	1603	+	m->monitor = i;
1583	1604
1584	1605		if (mcount != 1 && isxinerama) {
1585	1606		m->sx = info[i].x_org;

1591	1612		else {
1592	1613		m->sx = 0;
1593	1614		m->sy = 0;
1594		-	m->sw = DisplayWidth(dpy, m->screen);
1595		-	m->sh = DisplayHeight(dpy, m->screen);
	1615	+	m->sw = DisplayWidth(dpy, screen);
	1616	+	m->sh = DisplayHeight(dpy, screen);
1596	1617		}
1597	1618
1598	1619		m->seltags = emallocz(sizeof initags);

1601	1622		memcpy(m->seltags, initags, sizeof initags);
1602	1623		memcpy(m->prevtags, initags, sizeof initags);
1603	1624
1604		-	/* init appearance */
1605		-	m->dc.norm[ColBorder] = getcolor(NORMBORDERCOLOR, m->screen);
1606		-	m->dc.norm[ColBG] = getcolor(NORMBGCOLOR, m->screen);
1607		-	m->dc.norm[ColFG] = getcolor(NORMFGCOLOR, m->screen);
1608		-	m->dc.sel[ColBorder] = getcolor(SELBORDERCOLOR, m->screen);
1609		-	m->dc.sel[ColBG] = getcolor(SELBGCOLOR, m->screen);
1610		-	m->dc.sel[ColFG] = getcolor(SELFGCOLOR, m->screen);
1611		-	initfont(m, FONT);
1612		-	m->dc.h = bh = m->dc.font.height + 2;
1613		-
1614	1625		/* init layouts */
1615	1626		m->mwfact = MWFACT;
1616	1627		m->layout = &layouts[0];
1617		-	for(blw = k = 0; k < LENGTH(layouts); k++) {
1618		-	j = textw(m, layouts[k].symbol);
1619		-	if(j > blw)
1620		-	blw = j;
1621		-	}
1622	1628
1623	1629		// TODO: bpos per screen?
1624	1630		bpos = BARPOS;

1628	1634
1629	1635		/* init bars */
1630	1636		m->barwin = XCreateWindow(dpy, root, m->sx, m->sy, m->sw, bh, 0,
1631		-	DefaultDepth(dpy, m->screen), CopyFromParent, DefaultVisual(dpy, m->screen),
	1637	+	DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen),
1632	1638		CWOverrideRedirect \| CWBackPixmap \| CWEventMask, &wa);
1633	1639		XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
1634	1640		updatebarpos(m);
1635	1641		XMapRaised(dpy, m->barwin);
1636	1642		strcpy(stext, "dwm-"VERSION);
1637		-	m->dc.drawable = XCreatePixmap(dpy, root, m->sw, bh, DefaultDepth(dpy, m->screen));
1638		-	m->dc.gc = XCreateGC(dpy, root, 0, 0);
1639		-	XSetLineAttributes(dpy, m->dc.gc, 1, LineSolid, CapButt, JoinMiter);
1640		-	if(!m->dc.font.set)
1641		-	XSetFont(dpy, m->dc.gc, m->dc.font.xfont->fid);
1642	1643
1643	1644		/* EWMH support per monitor */
1644	1645		XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,

1700	1701		}
1701	1702
1702	1703		unsigned int
1703		-	textnw(Monitor m, const char text, unsigned int len) {
	1704	+	textnw(const char *text, unsigned int len) {
1704	1705		XRectangle r;
1705	1706
1706		-	if(m->dc.font.set) {
1707		-	XmbTextExtents(m->dc.font.set, text, len, NULL, &r);
	1707	+	if(dc.font.set) {
	1708	+	XmbTextExtents(dc.font.set, text, len, NULL, &r);
1708	1709		return r.width;
1709	1710		}
1710		-	return XTextWidth(m->dc.font.xfont, text, len);
	1711	+	return XTextWidth(dc.font.xfont, text, len);
1711	1712		}
1712	1713
1713	1714		unsigned int
1714		-	textw(Monitor m, const char text) {
1715		-	return textnw(m, text, strlen(text)) + m->dc.font.height;
	1715	+	textw(const char *text) {
	1716	+	return textnw(text, strlen(text)) + dc.font.height;
1716	1717		}
1717	1718
1718	1719		void