git.stevedylan.dev

moved bar-related stuff to bar.c (merged draw.c into that) 7e476fb8

Anselm R. Garbe · 2007-09-15 13:16 6 file(s) · +269 −259

Makefile +1 −1


include config.mk

SRC += client.c draw.c event.c main.c screen.c util.c
SRC += bar.c client.c event.c main.c screen.c util.c
OBJ = ${SRC:.c=.o}

all: options dwm

bar.c (added) +258 −0

1	+	/* See LICENSE file for copyright and license details. */
2	+	#include "dwm.h"
3	+	#include <string.h>
4	+	#include <stdio.h>
5	+
6	+	/* static */
7	+
8	+	static void
9	+	drawsquare(Bool filled, Bool empty, unsigned long col[ColLast]) {
10	+	int x;
11	+	XGCValues gcv;
12	+	XRectangle r = { dc.x, dc.y, dc.w, dc.h };
13	+
14	+	gcv.foreground = col[ColFG];
15	+	XChangeGC(dpy, dc.gc, GCForeground, &gcv);
16	+	x = (dc.font.ascent + dc.font.descent + 2) / 4;
17	+	r.x = dc.x + 1;
18	+	r.y = dc.y + 1;
19	+	if(filled) {
20	+	r.width = r.height = x + 1;
21	+	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
22	+	}
23	+	else if(empty) {
24	+	r.width = r.height = x;
25	+	XDrawRectangles(dpy, dc.drawable, dc.gc, &r, 1);
26	+	}
27	+	}
28	+
29	+	static unsigned long
30	+	initcolor(const char *colstr) {
31	+	Colormap cmap = DefaultColormap(dpy, screen);
32	+	XColor color;
33	+
34	+	if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
35	+	eprint("error, cannot allocate color '%s'\n", colstr);
36	+	return color.pixel;
37	+	}
38	+
39	+	static void
40	+	initfont(const char *fontstr) {
41	+	char def, *missing;
42	+	int i, n;
43	+
44	+	missing = NULL;
45	+	if(dc.font.set)
46	+	XFreeFontSet(dpy, dc.font.set);
47	+	dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
48	+	if(missing) {
49	+	while(n--)
50	+	fprintf(stderr, "dwm: missing fontset: %s\n", missing[n]);
51	+	XFreeStringList(missing);
52	+	}
53	+	if(dc.font.set) {
54	+	XFontSetExtents *font_extents;
55	+	XFontStruct **xfonts;
56	+	char **font_names;
57	+	dc.font.ascent = dc.font.descent = 0;
58	+	font_extents = XExtentsOfFontSet(dc.font.set);
59	+	n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);
60	+	for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {
61	+	if(dc.font.ascent < (*xfonts)->ascent)
62	+	dc.font.ascent = (*xfonts)->ascent;
63	+	if(dc.font.descent < (*xfonts)->descent)
64	+	dc.font.descent = (*xfonts)->descent;
65	+	xfonts++;
66	+	}
67	+	}
68	+	else {
69	+	if(dc.font.xfont)
70	+	XFreeFont(dpy, dc.font.xfont);
71	+	dc.font.xfont = NULL;
72	+	if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr)))
73	+	eprint("error, cannot load font: '%s'\n", fontstr);
74	+	dc.font.ascent = dc.font.xfont->ascent;
75	+	dc.font.descent = dc.font.xfont->descent;
76	+	}
77	+	dc.font.height = dc.font.ascent + dc.font.descent;
78	+	}
79	+
80	+	static Bool
81	+	isoccupied(unsigned int t) {
82	+	Client *c;
83	+
84	+	for(c = clients; c; c = c->next)
85	+	if(c->tags[t])
86	+	return True;
87	+	return False;
88	+	}
89	+
90	+	static unsigned int
91	+	textnw(const char *text, unsigned int len) {
92	+	XRectangle r;
93	+
94	+	if(dc.font.set) {
95	+	XmbTextExtents(dc.font.set, text, len, NULL, &r);
96	+	return r.width;
97	+	}
98	+	return XTextWidth(dc.font.xfont, text, len);
99	+	}
100	+
101	+	static void
102	+	drawtext(const char *text, unsigned long col[ColLast]) {
103	+	int x, y, w, h;
104	+	static char buf[256];
105	+	unsigned int len, olen;
106	+	XRectangle r = { dc.x, dc.y, dc.w, dc.h };
107	+
108	+	XSetForeground(dpy, dc.gc, col[ColBG]);
109	+	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
110	+	if(!text)
111	+	return;
112	+	w = 0;
113	+	olen = len = strlen(text);
114	+	if(len >= sizeof buf)
115	+	len = sizeof buf - 1;
116	+	memcpy(buf, text, len);
117	+	buf[len] = 0;
118	+	h = dc.font.ascent + dc.font.descent;
119	+	y = dc.y + (dc.h / 2) - (h / 2) + dc.font.ascent;
120	+	x = dc.x + (h / 2);
121	+	/* shorten text if necessary */
122	+	while(len && (w = textnw(buf, len)) > dc.w - h)
123	+	buf[--len] = 0;
124	+	if(len < olen) {
125	+	if(len > 1)
126	+	buf[len - 1] = '.';
127	+	if(len > 2)
128	+	buf[len - 2] = '.';
129	+	if(len > 3)
130	+	buf[len - 3] = '.';
131	+	}
132	+	if(w > dc.w)
133	+	return; /* too long */
134	+	XSetForeground(dpy, dc.gc, col[ColFG]);
135	+	if(dc.font.set)
136	+	XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);
137	+	else
138	+	XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);
139	+	}
140	+
141	+	/* extern */
142	+
143	+	unsigned int bh;
144	+	unsigned int bpos = BARPOS;
145	+	DC dc = {0};
146	+	Window barwin;
147	+
148	+	void
149	+	drawbar(void) {
150	+	int i, x;
151	+
152	+	dc.x = dc.y = 0;
153	+	for(i = 0; i < ntags; i++) {
154	+	dc.w = textw(tags[i]);
155	+	if(seltags[i]) {
156	+	drawtext(tags[i], dc.sel);
157	+	drawsquare(sel && sel->tags[i], isoccupied(i), dc.sel);
158	+	}
159	+	else {
160	+	drawtext(tags[i], dc.norm);
161	+	drawsquare(sel && sel->tags[i], isoccupied(i), dc.norm);
162	+	}
163	+	dc.x += dc.w;
164	+	}
165	+	dc.w = blw;
166	+	drawtext(getsymbol(), dc.norm);
167	+	x = dc.x + dc.w;
168	+	dc.w = textw(stext);
169	+	dc.x = sw - dc.w;
170	+	if(dc.x < x) {
171	+	dc.x = x;
172	+	dc.w = sw - x;
173	+	}
174	+	drawtext(stext, dc.norm);
175	+	if((dc.w = dc.x - x) > bh) {
176	+	dc.x = x;
177	+	if(sel) {
178	+	drawtext(sel->name, dc.sel);
179	+	drawsquare(sel->ismax, sel->isfloating, dc.sel);
180	+	}
181	+	else
182	+	drawtext(NULL, dc.norm);
183	+	}
184	+	XCopyArea(dpy, dc.drawable, barwin, dc.gc, 0, 0, sw, bh, 0, 0);
185	+	XSync(dpy, False);
186	+	}
187	+
188	+	void
189	+	initbar(void) {
190	+	XSetWindowAttributes wa;
191	+
192	+	dc.norm[ColBorder] = initcolor(NORMBORDERCOLOR);
193	+	dc.norm[ColBG] = initcolor(NORMBGCOLOR);
194	+	dc.norm[ColFG] = initcolor(NORMFGCOLOR);
195	+	dc.sel[ColBorder] = initcolor(SELBORDERCOLOR);
196	+	dc.sel[ColBG] = initcolor(SELBGCOLOR);
197	+	dc.sel[ColFG] = initcolor(SELFGCOLOR);
198	+	initfont(FONT);
199	+	dc.h = bh = dc.font.height + 2;
200	+	wa.override_redirect = 1;
201	+	wa.background_pixmap = ParentRelative;
202	+	wa.event_mask = ButtonPressMask \| ExposureMask;
203	+	barwin = XCreateWindow(dpy, root, sx, sy, sw, bh, 0,
204	+	DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen),
205	+	CWOverrideRedirect \| CWBackPixmap \| CWEventMask, &wa);
206	+	XDefineCursor(dpy, barwin, cursor[CurNormal]);
207	+	updatebarpos();
208	+	XMapRaised(dpy, barwin);
209	+	strcpy(stext, "dwm-"VERSION);
210	+	dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
211	+	dc.gc = XCreateGC(dpy, root, 0, 0);
212	+	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
213	+	if(!dc.font.set)
214	+	XSetFont(dpy, dc.gc, dc.font.xfont->fid);
215	+	}
216	+
217	+	unsigned int
218	+	textw(const char *text) {
219	+	return textnw(text, strlen(text)) + dc.font.height;
220	+	}
221	+
222	+	void
223	+	togglebar(const char *arg) {
224	+	if(bpos == BarOff)
225	+	bpos = (BARPOS == BarOff) ? BarTop : BARPOS;
226	+	else
227	+	bpos = BarOff;
228	+	updatebarpos();
229	+	arrange();
230	+	}
231	+
232	+	void
233	+	updatebarpos(void) {
234	+	XEvent ev;
235	+
236	+	wax = sx;
237	+	way = sy;
238	+	wah = sh;
239	+	waw = sw;
240	+	switch(bpos) {
241	+	default:
242	+	wah -= bh;
243	+	way += bh;
244	+	XMoveWindow(dpy, barwin, sx, sy);
245	+	break;
246	+	case BarBot:
247	+	wah -= bh;
248	+	XMoveWindow(dpy, barwin, sx, sy + wah);
249	+	break;
250	+	case BarOff:
251	+	XMoveWindow(dpy, barwin, sx, sy - bh);
252	+	break;
253	+	}
254	+	XSync(dpy, False);
255	+	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
256	+	}
257	+
258	+

draw.c (deleted) +0 −134

/* See LICENSE file for copyright and license details. */
#include "dwm.h"
#include <string.h>

/* static */

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

	gcv.foreground = col[ColFG];
	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, dc.drawable, dc.gc, &r, 1);
	}
	else if(empty) {
		r.width = r.height = x;
		XDrawRectangles(dpy, dc.drawable, dc.gc, &r, 1);
	}
}

static Bool
isoccupied(unsigned int t) {
	Client *c;

	for(c = clients; c; c = c->next)
		if(c->tags[t])
			return True;
	return False;
}

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

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

/* extern */

void
drawbar(void) {
	int i, x;

	dc.x = dc.y = 0;
	for(i = 0; i < ntags; i++) {
		dc.w = textw(tags[i]);
		if(seltags[i]) {
			drawtext(tags[i], dc.sel);
			drawsquare(sel && sel->tags[i], isoccupied(i), dc.sel);
		}
		else {
			drawtext(tags[i], dc.norm);
			drawsquare(sel && sel->tags[i], isoccupied(i), dc.norm);
		}
		dc.x += dc.w;
	}
	dc.w = blw;
	drawtext(getsymbol(), dc.norm);
	x = dc.x + dc.w;
	dc.w = textw(stext);
	dc.x = sw - dc.w;
	if(dc.x < x) {
		dc.x = x;
		dc.w = sw - x;
	}
	drawtext(stext, dc.norm);
	if((dc.w = dc.x - x) > bh) {
		dc.x = x;
		if(sel) {
			drawtext(sel->name, dc.sel);
			drawsquare(sel->ismax, sel->isfloating, dc.sel);
		}
		else
			drawtext(NULL, dc.norm);
	}
	XCopyArea(dpy, dc.drawable, barwin, dc.gc, 0, 0, sw, bh, 0, 0);
	XSync(dpy, False);
}

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

	XSetForeground(dpy, dc.gc, col[ColBG]);
	XFillRectangles(dpy, dc.drawable, dc.gc, &r, 1);
	if(!text)
		return;
	w = 0;
	olen = len = strlen(text);
	if(len >= sizeof buf)
		len = sizeof buf - 1;
	memcpy(buf, text, len);
	buf[len] = 0;
	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(buf, len)) > dc.w - h)
		buf[--len] = 0;
	if(len < olen) {
		if(len > 1)
			buf[len - 1] = '.';
		if(len > 2)
			buf[len - 2] = '.';
		if(len > 3)
			buf[len - 3] = '.';
	}
	if(w > dc.w)
		return; /* too long */
	XSetForeground(dpy, dc.gc, col[ColFG]);
	if(dc.font.set)
		XmbDrawString(dpy, dc.drawable, dc.font.set, dc.gc, x, y, buf, len);
	else
		XDrawString(dpy, dc.drawable, dc.gc, x, y, buf, len);
}

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

dwm.h +7 −7

extern Display *dpy;
extern Window root, barwin;

/* bar.c */
void drawbar(void);			/* draw the bar */
void initbar(void);			/* initializes the bar */
unsigned int textw(const char *text);	/* return the width of text in px*/
void togglebar(const char *arg);	/* shows/hides the bar */
void updatebarpos(void);		/* updates the bar position */

/* client.c */
void attach(Client *c);			/* attaches c to global client list */
void ban(Client *c);			/* bans c */

void unmanage(Client *c);		/* unmanage c */
void updatesizehints(Client *c);	/* update the size hint variables of c */
void updatetitle(Client *c);		/* update the name of c */

/* draw.c */
void drawbar(void);			/* draw the bar */
void drawtext(const char *text, unsigned long col[ColLast]);	/* draw text */
unsigned int textw(const char *text);	/* return the width of text in px*/

/* event.c */
void grabkeys(void);			/* grab all keys defined in config.h */

void restack(void);			/* restores z layers of all clients */
void setlayout(const char *arg);	/* sets layout, NULL means next layout */
void tag(const char *arg);		/* tags sel with arg's index */
void togglebar(const char *arg);	/* shows/hides the bar */
void togglefloating(const char *arg);	/* toggles sel between floating/tiled state */
void togglemax(const char *arg);	/* toggles maximization of floating client */
void toggletag(const char *arg);	/* toggles sel tags with arg's index */
void toggleview(const char *arg);	/* toggles the tag with arg's index (in)visible */
void updatebarpos(void);		/* updates the bar position */
void view(const char *arg);		/* views the tag with arg's index */

/* util.c */

main.c +3 −81


char stext[256];
int screen, sx, sy, sw, sh, wax, way, waw, wah;
unsigned int bh, ntags;
unsigned int bpos = BARPOS;
unsigned int ntags;
unsigned int numlockmask = 0;
Atom wmatom[WMLast], netatom[NetLast];
Bool *seltags;

Client *stack = NULL;
Cursor cursor[CurLast];
Display *dpy;
DC dc = {0};
Window root, barwin;
Window root;

/* static */


	free(seltags);
}

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

	if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
		eprint("error, cannot allocate color '%s'\n", colstr);
	return color.pixel;
}

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

	missing = NULL;
	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(dc.font.set) {
		XFontSetExtents *font_extents;
		XFontStruct **xfonts;
		char **font_names;
		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(dc.font.xfont)
			XFreeFont(dpy, dc.font.xfont);
		dc.font.xfont = NULL;
		if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr)))
			eprint("error, cannot load font: '%s'\n", fontstr);
		dc.font.ascent = dc.font.xfont->ascent;
		dc.font.descent = dc.font.xfont->descent;
	}
	dc.font.height = dc.font.ascent + dc.font.descent;
}

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

	for(ntags = 0; tags[ntags]; ntags++);
	seltags = emallocz(sizeof(Bool) * ntags);
	seltags[0] = True;
	/* style */
	dc.norm[ColBorder] = initcolor(NORMBORDERCOLOR);
	dc.norm[ColBG] = initcolor(NORMBGCOLOR);
	dc.norm[ColFG] = initcolor(NORMFGCOLOR);
	dc.sel[ColBorder] = initcolor(SELBORDERCOLOR);
	dc.sel[ColBG] = initcolor(SELBGCOLOR);
	dc.sel[ColFG] = initcolor(SELFGCOLOR);
	initfont(FONT);
	/* geometry */
	sx = sy = 0;
	sw = DisplayWidth(dpy, screen);
	sh = DisplayHeight(dpy, screen);
	initlayouts();
	/* bar */
	dc.h = bh = dc.font.height + 2;
	wa.override_redirect = 1;
	wa.background_pixmap = ParentRelative;
	wa.event_mask = ButtonPressMask | ExposureMask;
	barwin = XCreateWindow(dpy, root, sx, sy, sw, bh, 0,
			DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen),
			CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa);
	XDefineCursor(dpy, barwin, cursor[CurNormal]);
	updatebarpos();
	XMapRaised(dpy, barwin);
	strcpy(stext, "dwm-"VERSION);
	/* pixmap for everything */
	dc.drawable = XCreatePixmap(dpy, root, sw, 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);
	initbar();
	/* multihead support */
	selscreen = XQueryPointer(dpy, root, &w, &w, &i, &i, &i, &i, &mask);
}

screen.c +0 −36

}

void
togglebar(const char *arg) {
	if(bpos == BarOff)
		bpos = (BARPOS == BarOff) ? BarTop : BARPOS;
	else
		bpos = BarOff;
	updatebarpos();
	arrange();
}

void
togglefloating(const char *arg) {
	if(!sel)
		return;

	if(j == ntags)
		seltags[i] = True; /* cannot toggle last view */
	arrange();
}

void
updatebarpos(void) {
	XEvent ev;

	wax = sx;
	way = sy;
	wah = sh;
	waw = sw;
	switch(bpos) {
	default:
		wah -= bh;
		way += bh;
		XMoveWindow(dpy, barwin, sx, sy);
		break;
	case BarBot:
		wah -= bh;
		XMoveWindow(dpy, barwin, sx, sy + wah);
		break;
	case BarOff:
		XMoveWindow(dpy, barwin, sx, sy - bh);
		break;
	}
	XSync(dpy, False);
	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
}

void

273	273		}
274	274
275	275		void
276		-	togglebar(const char *arg) {
277		-	if(bpos == BarOff)
278		-	bpos = (BARPOS == BarOff) ? BarTop : BARPOS;
279		-	else
280		-	bpos = BarOff;
281		-	updatebarpos();
282		-	arrange();
283		-	}
284		-
285		-	void
286	276		togglefloating(const char *arg) {
287	277		if(!sel)
288	278		return;

335	325		if(j == ntags)
336	326		seltags[i] = True; /* cannot toggle last view */
337	327		arrange();
338		-	}
339		-
340		-	void
341		-	updatebarpos(void) {
342		-	XEvent ev;
343		-
344		-	wax = sx;
345		-	way = sy;
346		-	wah = sh;
347		-	waw = sw;
348		-	switch(bpos) {
349		-	default:
350		-	wah -= bh;
351		-	way += bh;
352		-	XMoveWindow(dpy, barwin, sx, sy);
353		-	break;
354		-	case BarBot:
355		-	wah -= bh;
356		-	XMoveWindow(dpy, barwin, sx, sy + wah);
357		-	break;
358		-	case BarOff:
359		-	XMoveWindow(dpy, barwin, sx, sy - bh);
360		-	break;
361		-	}
362		-	XSync(dpy, False);
363		-	while(XCheckMaskEvent(dpy, EnterWindowMask, &ev));
364	328		}
365	329
366	330		void

3	3
4	4		include config.mk
5	5
6		-	SRC += client.c draw.c event.c main.c screen.c util.c
	6	+	SRC += bar.c client.c event.c main.c screen.c util.c
7	7		OBJ = ${SRC:.c=.o}
8	8
9	9		all: options dwm

88	88		extern Display *dpy;
89	89		extern Window root, barwin;
90	90
	91	+	/* bar.c */
	92	+	void drawbar(void); /* draw the bar */
	93	+	void initbar(void); /* initializes the bar */
	94	+	unsigned int textw(const char text); / return the width of text in px*/
	95	+	void togglebar(const char arg); / shows/hides the bar */
	96	+	void updatebarpos(void); /* updates the bar position */
	97	+
91	98		/* client.c */
92	99		void attach(Client c); / attaches c to global client list */
93	100		void ban(Client c); / bans c */

102	109		void unmanage(Client c); / unmanage c */
103	110		void updatesizehints(Client c); / update the size hint variables of c */
104	111		void updatetitle(Client c); / update the name of c */
105		-
106		-	/* draw.c */
107		-	void drawbar(void); /* draw the bar */
108		-	void drawtext(const char text, unsigned long col[ColLast]); / draw text */
109		-	unsigned int textw(const char text); / return the width of text in px*/
110	112
111	113		/* event.c */
112	114		void grabkeys(void); /* grab all keys defined in config.h */

132	134		void restack(void); /* restores z layers of all clients */
133	135		void setlayout(const char arg); / sets layout, NULL means next layout */
134	136		void tag(const char arg); / tags sel with arg's index */
135		-	void togglebar(const char arg); / shows/hides the bar */
136	137		void togglefloating(const char arg); / toggles sel between floating/tiled state */
137	138		void togglemax(const char arg); / toggles maximization of floating client */
138	139		void toggletag(const char arg); / toggles sel tags with arg's index */
139	140		void toggleview(const char arg); / toggles the tag with arg's index (in)visible */
140		-	void updatebarpos(void); /* updates the bar position */
141	141		void view(const char arg); / views the tag with arg's index */
142	142
143	143		/* util.c */

17	17
18	18		char stext[256];
19	19		int screen, sx, sy, sw, sh, wax, way, waw, wah;
20		-	unsigned int bh, ntags;
21		-	unsigned int bpos = BARPOS;
	20	+	unsigned int ntags;
22	21		unsigned int numlockmask = 0;
23	22		Atom wmatom[WMLast], netatom[NetLast];
24	23		Bool *seltags;

28	27		Client *stack = NULL;
29	28		Cursor cursor[CurLast];
30	29		Display *dpy;
31		-	DC dc = {0};
32		-	Window root, barwin;
	30	+	Window root;
33	31
34	32		/* static */
35	33

60	58		free(seltags);
61	59		}
62	60
63		-	static unsigned long
64		-	initcolor(const char *colstr) {
65		-	Colormap cmap = DefaultColormap(dpy, screen);
66		-	XColor color;
67		-
68		-	if(!XAllocNamedColor(dpy, cmap, colstr, &color, &color))
69		-	eprint("error, cannot allocate color '%s'\n", colstr);
70		-	return color.pixel;
71		-	}
72		-
73		-	static void
74		-	initfont(const char *fontstr) {
75		-	char def, *missing;
76		-	int i, n;
77		-
78		-	missing = NULL;
79		-	if(dc.font.set)
80		-	XFreeFontSet(dpy, dc.font.set);
81		-	dc.font.set = XCreateFontSet(dpy, fontstr, &missing, &n, &def);
82		-	if(missing) {
83		-	while(n--)
84		-	fprintf(stderr, "dwm: missing fontset: %s\n", missing[n]);
85		-	XFreeStringList(missing);
86		-	}
87		-	if(dc.font.set) {
88		-	XFontSetExtents *font_extents;
89		-	XFontStruct **xfonts;
90		-	char **font_names;
91		-	dc.font.ascent = dc.font.descent = 0;
92		-	font_extents = XExtentsOfFontSet(dc.font.set);
93		-	n = XFontsOfFontSet(dc.font.set, &xfonts, &font_names);
94		-	for(i = 0, dc.font.ascent = 0, dc.font.descent = 0; i < n; i++) {
95		-	if(dc.font.ascent < (*xfonts)->ascent)
96		-	dc.font.ascent = (*xfonts)->ascent;
97		-	if(dc.font.descent < (*xfonts)->descent)
98		-	dc.font.descent = (*xfonts)->descent;
99		-	xfonts++;
100		-	}
101		-	}
102		-	else {
103		-	if(dc.font.xfont)
104		-	XFreeFont(dpy, dc.font.xfont);
105		-	dc.font.xfont = NULL;
106		-	if(!(dc.font.xfont = XLoadQueryFont(dpy, fontstr)))
107		-	eprint("error, cannot load font: '%s'\n", fontstr);
108		-	dc.font.ascent = dc.font.xfont->ascent;
109		-	dc.font.descent = dc.font.xfont->descent;
110		-	}
111		-	dc.font.height = dc.font.ascent + dc.font.descent;
112		-	}
113		-
114	61		static long
115	62		getstate(Window w) {
116	63		int format, status;

197	144		for(ntags = 0; tags[ntags]; ntags++);
198	145		seltags = emallocz(sizeof(Bool) * ntags);
199	146		seltags[0] = True;
200		-	/* style */
201		-	dc.norm[ColBorder] = initcolor(NORMBORDERCOLOR);
202		-	dc.norm[ColBG] = initcolor(NORMBGCOLOR);
203		-	dc.norm[ColFG] = initcolor(NORMFGCOLOR);
204		-	dc.sel[ColBorder] = initcolor(SELBORDERCOLOR);
205		-	dc.sel[ColBG] = initcolor(SELBGCOLOR);
206		-	dc.sel[ColFG] = initcolor(SELFGCOLOR);
207		-	initfont(FONT);
208	147		/* geometry */
209	148		sx = sy = 0;
210	149		sw = DisplayWidth(dpy, screen);
211	150		sh = DisplayHeight(dpy, screen);
212	151		initlayouts();
213		-	/* bar */
214		-	dc.h = bh = dc.font.height + 2;
215		-	wa.override_redirect = 1;
216		-	wa.background_pixmap = ParentRelative;
217		-	wa.event_mask = ButtonPressMask \| ExposureMask;
218		-	barwin = XCreateWindow(dpy, root, sx, sy, sw, bh, 0,
219		-	DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen),
220		-	CWOverrideRedirect \| CWBackPixmap \| CWEventMask, &wa);
221		-	XDefineCursor(dpy, barwin, cursor[CurNormal]);
222		-	updatebarpos();
223		-	XMapRaised(dpy, barwin);
224		-	strcpy(stext, "dwm-"VERSION);
225		-	/* pixmap for everything */
226		-	dc.drawable = XCreatePixmap(dpy, root, sw, bh, DefaultDepth(dpy, screen));
227		-	dc.gc = XCreateGC(dpy, root, 0, 0);
228		-	XSetLineAttributes(dpy, dc.gc, 1, LineSolid, CapButt, JoinMiter);
229		-	if(!dc.font.set)
230		-	XSetFont(dpy, dc.gc, dc.font.xfont->fid);
	152	+	initbar();
231	153		/* multihead support */
232	154		selscreen = XQueryPointer(dpy, root, &w, &w, &i, &i, &i, &i, &mask);
233	155		}