git.stevedylan.dev

removed Monitor->root, since we do not support classical multihead 191cb9ce

Anselm R Garbe · 2008-02-18 16:47 1 file(s) · +49 −54

dwm.c +49 −54


typedef struct {
	int screen;
	Window root;
	Window barwin;
	int sx, sy, sw, sh, wax, way, wah, waw;
	DC dc;

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

DC dc = {0};
Regs *regs = NULL;
Monitor *monitors;
int selmonitor = 0;
Window root;

/* configuration, allows nested code to access above variables */
#include "config.h"

			XFreeFontSet(dpy, m->dc.font.set);
		else
			XFreeFont(dpy, m->dc.font.xfont);
		XUngrabKey(dpy, AnyKey, AnyModifier, m->root);
		XUngrabKey(dpy, AnyKey, AnyModifier, root);
		XFreePixmap(dpy, m->dc.drawable);
		XFreeGC(dpy, m->dc.gc);
		XDestroyWindow(dpy, m->barwin);

	XConfigureEvent *ev = &e->xconfigure;
	Monitor *m = &monitors[selmonitor];

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

	XCrossingEvent *ev = &e->xcrossing;

	if(ev->mode != NotifyNormal || ev->detail == NotifyInferior) {
		if(!isxinerama || ev->window != monitors[selmonitor].root)
		if(!isxinerama || ev->window != root)
			return;
	}
	if((c = getclient(ev->window)))

		selmonitor = c->monitor;
	}
	else {
		XSetInputFocus(dpy, m->root, RevertToPointerRoot, CurrentTime);
		XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
		drawbar();
	}
}

		}
	XFreeModifiermap(modmap);

	for(i = 0; i < mcount; i++) {
		Monitor *m = &monitors[i];
		XUngrabKey(dpy, AnyKey, AnyModifier, m->root);
		for(j = 0; j < LENGTH(keys); j++) {
			code = XKeysymToKeycode(dpy, keys[j].keysym);
			XGrabKey(dpy, code, keys[j].mod, m->root, True,
					GrabModeAsync, GrabModeAsync);
			XGrabKey(dpy, code, keys[j].mod | LockMask, m->root, True,
					GrabModeAsync, GrabModeAsync);
			XGrabKey(dpy, code, keys[j].mod | numlockmask, m->root, True,
					GrabModeAsync, GrabModeAsync);
			XGrabKey(dpy, code, keys[j].mod | numlockmask | LockMask, m->root, True,
					GrabModeAsync, GrabModeAsync);
		}
	XUngrabKey(dpy, AnyKey, AnyModifier, root);
	for(i = 0; i < LENGTH(keys); i++) {
		code = XKeysymToKeycode(dpy, keys[i].keysym);
		XGrabKey(dpy, code, keys[i].mod, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, keys[i].mod | LockMask, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, keys[i].mod | numlockmask, root, True,
				GrabModeAsync, GrabModeAsync);
		XGrabKey(dpy, code, keys[i].mod | numlockmask | LockMask, root, True,
				GrabModeAsync, GrabModeAsync);
	}
}


	Window win;
	unsigned int mask;

	XQueryPointer(dpy, monitors[selmonitor].root, &win, &win, &x, &y, &i, &i, &mask);
	XQueryPointer(dpy, root, &win, &win, &x, &y, &i, &i, &mask);
	for(i = 0; i < mcount; i++) {
		if((x >= monitors[i].sx && x < monitors[i].sx + monitors[i].sw)
		&& (y >= monitors[i].sy && y < monitors[i].sy + monitors[i].sh)) {


	ocx = nx = c->x;
	ocy = ny = c->y;
	if(XGrabPointer(dpy, monitors[selmonitor].root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
			None, cursor[CurMove], CurrentTime) != GrabSuccess)
		return;
	XQueryPointer(dpy, monitors[selmonitor].root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
	XQueryPointer(dpy, root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
	for(;;) {
		XMaskEvent(dpy, MOUSEMASK | ExposureMask | SubstructureRedirectMask, &ev);
		switch (ev.type) {


	ocx = c->x;
	ocy = c->y;
	if(XGrabPointer(dpy, monitors[selmonitor].root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
			None, cursor[CurResize], CurrentTime) != GrabSuccess)
		return;
	XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);


void
scan(void) {
	unsigned int i, j, num;
	unsigned int i, num;
	Window *wins, d1, d2;
	XWindowAttributes wa;

	for(i = 0; i < mcount; i++) {
		Monitor *m = &monitors[i];
		wins = NULL;
		if(XQueryTree(dpy, m->root, &d1, &d2, &wins, &num)) {
			for(j = 0; j < num; j++) {
				if(!XGetWindowAttributes(dpy, wins[j], &wa)
				|| wa.override_redirect || XGetTransientForHint(dpy, wins[j], &d1))
					continue;
				if(wa.map_state == IsViewable || getstate(wins[j]) == IconicState)
					manage(wins[j], &wa);
			}
			for(j = 0; j < num; j++) { /* now the transients */
				if(!XGetWindowAttributes(dpy, wins[j], &wa))
					continue;
				if(XGetTransientForHint(dpy, wins[j], &d1)
				&& (wa.map_state == IsViewable || getstate(wins[j]) == IconicState))
					manage(wins[j], &wa);
			}
	wins = NULL;
	if(XQueryTree(dpy, root, &d1, &d2, &wins, &num)) {
		for(i = 0; i < num; i++) {
			if(!XGetWindowAttributes(dpy, wins[i], &wa)
					|| wa.override_redirect || XGetTransientForHint(dpy, wins[i], &d1))
				continue;
			if(wa.map_state == IsViewable || getstate(wins[i]) == IconicState)
				manage(wins[i], &wa);
		}
		for(i = 0; i < num; i++) { /* now the transients */
			if(!XGetWindowAttributes(dpy, wins[i], &wa))
				continue;
			if(XGetTransientForHint(dpy, wins[i], &d1)
					&& (wa.map_state == IsViewable || getstate(wins[i]) == IconicState))
				manage(wins[i], &wa);
		}
		if(wins)
			XFree(wins);
	}
	if(wins)
		XFree(wins);
}

void

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

	root = DefaultRootWindow(dpy);

	for(i = 0; i < mcount; i++) {
		/* init geometry */
		m = &monitors[i];

		m->screen = isxinerama ? 0 : i;
		m->root = RootWindow(dpy, m->screen);

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

		wa.event_mask = ButtonPressMask | ExposureMask;

		/* init bars */
		m->barwin = XCreateWindow(dpy, m->root, m->sx, m->sy, m->sw, bh, 0,
		m->barwin = XCreateWindow(dpy, root, m->sx, m->sy, m->sw, bh, 0,
				DefaultDepth(dpy, m->screen), CopyFromParent, DefaultVisual(dpy, m->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, m->root, m->sw, bh, DefaultDepth(dpy, m->screen));
		m->dc.gc = XCreateGC(dpy, m->root, 0, 0);
		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, m->root, netatom[NetSupported], XA_ATOM, 32,
		XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
				PropModeReplace, (unsigned char *) netatom, NetLast);

		/* select for events */
		wa.event_mask = SubstructureRedirectMask | SubstructureNotifyMask
				| EnterWindowMask | LeaveWindowMask | StructureNotifyMask;
		XChangeWindowAttributes(dpy, m->root, CWEventMask | CWCursor, &wa);
		XSelectInput(dpy, m->root, wa.event_mask);
		XChangeWindowAttributes(dpy, root, CWEventMask | CWCursor, &wa);
		XSelectInput(dpy, root, wa.event_mask);
	}
	if(info)
		XFree(info);

selectmonitor(const char *arg) {
	Monitor *m = &monitors[arg ? atoi(arg) : (monitorat()+1) % mcount];

	XWarpPointer(dpy, None, m->root, 0, 0, 0, 0, m->wax+m->waw/2, m->way+m->wah/2);
	XWarpPointer(dpy, None, root, 0, 0, 0, 0, m->wax+m->waw/2, m->way+m->wah/2);
	focus(NULL);
}


118	118
119	119		typedef struct {
120	120		int screen;
121		-	Window root;
122	121		Window barwin;
123	122		int sx, sy, sw, sh, wax, way, wah, waw;
124	123		DC dc;

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

248	248		DC dc = {0};
249	249		Regs *regs = NULL;
250	250		Monitor *monitors;
251		-	int selmonitor = 0;
	251	+	Window root;
252	252
253	253		/* configuration, allows nested code to access above variables */
254	254		#include "config.h"

414	414		XFreeFontSet(dpy, m->dc.font.set);
415	415		else
416	416		XFreeFont(dpy, m->dc.font.xfont);
417		-	XUngrabKey(dpy, AnyKey, AnyModifier, m->root);
	417	+	XUngrabKey(dpy, AnyKey, AnyModifier, root);
418	418		XFreePixmap(dpy, m->dc.drawable);
419	419		XFreeGC(dpy, m->dc.gc);
420	420		XDestroyWindow(dpy, m->barwin);

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

687	687		XCrossingEvent *ev = &e->xcrossing;
688	688
689	689		if(ev->mode != NotifyNormal \|\| ev->detail == NotifyInferior) {
690		-	if(!isxinerama \|\| ev->window != monitors[selmonitor].root)
	690	+	if(!isxinerama \|\| ev->window != root)
691	691		return;
692	692		}
693	693		if((c = getclient(ev->window)))

755	755		selmonitor = c->monitor;
756	756		}
757	757		else {
758		-	XSetInputFocus(dpy, m->root, RevertToPointerRoot, CurrentTime);
	758	+	XSetInputFocus(dpy, root, RevertToPointerRoot, CurrentTime);
759	759		drawbar();
760	760		}
761	761		}

914	914		}
915	915		XFreeModifiermap(modmap);
916	916
917		-	for(i = 0; i < mcount; i++) {
918		-	Monitor *m = &monitors[i];
919		-	XUngrabKey(dpy, AnyKey, AnyModifier, m->root);
920		-	for(j = 0; j < LENGTH(keys); j++) {
921		-	code = XKeysymToKeycode(dpy, keys[j].keysym);
922		-	XGrabKey(dpy, code, keys[j].mod, m->root, True,
923		-	GrabModeAsync, GrabModeAsync);
924		-	XGrabKey(dpy, code, keys[j].mod \| LockMask, m->root, True,
925		-	GrabModeAsync, GrabModeAsync);
926		-	XGrabKey(dpy, code, keys[j].mod \| numlockmask, m->root, True,
927		-	GrabModeAsync, GrabModeAsync);
928		-	XGrabKey(dpy, code, keys[j].mod \| numlockmask \| LockMask, m->root, True,
929		-	GrabModeAsync, GrabModeAsync);
930		-	}
	917	+	XUngrabKey(dpy, AnyKey, AnyModifier, root);
	918	+	for(i = 0; i < LENGTH(keys); i++) {
	919	+	code = XKeysymToKeycode(dpy, keys[i].keysym);
	920	+	XGrabKey(dpy, code, keys[i].mod, root, True,
	921	+	GrabModeAsync, GrabModeAsync);
	922	+	XGrabKey(dpy, code, keys[i].mod \| LockMask, root, True,
	923	+	GrabModeAsync, GrabModeAsync);
	924	+	XGrabKey(dpy, code, keys[i].mod \| numlockmask, root, True,
	925	+	GrabModeAsync, GrabModeAsync);
	926	+	XGrabKey(dpy, code, keys[i].mod \| numlockmask \| LockMask, root, True,
	927	+	GrabModeAsync, GrabModeAsync);
931	928		}
932	929		}
933	930

1153	1150		Window win;
1154	1151		unsigned int mask;
1155	1152
1156		-	XQueryPointer(dpy, monitors[selmonitor].root, &win, &win, &x, &y, &i, &i, &mask);
	1153	+	XQueryPointer(dpy, root, &win, &win, &x, &y, &i, &i, &mask);
1157	1154		for(i = 0; i < mcount; i++) {
1158	1155		if((x >= monitors[i].sx && x < monitors[i].sx + monitors[i].sw)
1159	1156		&& (y >= monitors[i].sy && y < monitors[i].sy + monitors[i].sh)) {

1172	1169
1173	1170		ocx = nx = c->x;
1174	1171		ocy = ny = c->y;
1175		-	if(XGrabPointer(dpy, monitors[selmonitor].root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
	1172	+	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
1176	1173		None, cursor[CurMove], CurrentTime) != GrabSuccess)
1177	1174		return;
1178		-	XQueryPointer(dpy, monitors[selmonitor].root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
	1175	+	XQueryPointer(dpy, root, &dummy, &dummy, &x1, &y1, &di, &di, &dui);
1179	1176		for(;;) {
1180	1177		XMaskEvent(dpy, MOUSEMASK \| ExposureMask \| SubstructureRedirectMask, &ev);
1181	1178		switch (ev.type) {

1342	1339
1343	1340		ocx = c->x;
1344	1341		ocy = c->y;
1345		-	if(XGrabPointer(dpy, monitors[selmonitor].root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
	1342	+	if(XGrabPointer(dpy, root, False, MOUSEMASK, GrabModeAsync, GrabModeAsync,
1346	1343		None, cursor[CurResize], CurrentTime) != GrabSuccess)
1347	1344		return;
1348	1345		XWarpPointer(dpy, None, c->win, 0, 0, 0, 0, c->w + c->border - 1, c->h + c->border - 1);

1469	1466
1470	1467		void
1471	1468		scan(void) {
1472		-	unsigned int i, j, num;
	1469	+	unsigned int i, num;
1473	1470		Window *wins, d1, d2;
1474	1471		XWindowAttributes wa;
1475	1472
1476		-	for(i = 0; i < mcount; i++) {
1477		-	Monitor *m = &monitors[i];
1478		-	wins = NULL;
1479		-	if(XQueryTree(dpy, m->root, &d1, &d2, &wins, &num)) {
1480		-	for(j = 0; j < num; j++) {
1481		-	if(!XGetWindowAttributes(dpy, wins[j], &wa)
1482		-	\|\| wa.override_redirect \|\| XGetTransientForHint(dpy, wins[j], &d1))
1483		-	continue;
1484		-	if(wa.map_state == IsViewable \|\| getstate(wins[j]) == IconicState)
1485		-	manage(wins[j], &wa);
1486		-	}
1487		-	for(j = 0; j < num; j++) { /* now the transients */
1488		-	if(!XGetWindowAttributes(dpy, wins[j], &wa))
1489		-	continue;
1490		-	if(XGetTransientForHint(dpy, wins[j], &d1)
1491		-	&& (wa.map_state == IsViewable \|\| getstate(wins[j]) == IconicState))
1492		-	manage(wins[j], &wa);
1493		-	}
	1473	+	wins = NULL;
	1474	+	if(XQueryTree(dpy, root, &d1, &d2, &wins, &num)) {
	1475	+	for(i = 0; i < num; i++) {
	1476	+	if(!XGetWindowAttributes(dpy, wins[i], &wa)
	1477	+	\|\| wa.override_redirect \|\| XGetTransientForHint(dpy, wins[i], &d1))
	1478	+	continue;
	1479	+	if(wa.map_state == IsViewable \|\| getstate(wins[i]) == IconicState)
	1480	+	manage(wins[i], &wa);
	1481	+	}
	1482	+	for(i = 0; i < num; i++) { /* now the transients */
	1483	+	if(!XGetWindowAttributes(dpy, wins[i], &wa))
	1484	+	continue;
	1485	+	if(XGetTransientForHint(dpy, wins[i], &d1)
	1486	+	&& (wa.map_state == IsViewable \|\| getstate(wins[i]) == IconicState))
	1487	+	manage(wins[i], &wa);
1494	1488		}
1495		-	if(wins)
1496		-	XFree(wins);
1497	1489		}
	1490	+	if(wins)
	1491	+	XFree(wins);
1498	1492		}
1499	1493
1500	1494		void

1579	1573		info = XineramaQueryScreens(dpy, &mcount);
1580	1574		monitors = emallocz(mcount * sizeof(Monitor));
1581	1575
	1576	+	root = DefaultRootWindow(dpy);
	1577	+
1582	1578		for(i = 0; i < mcount; i++) {
1583	1579		/* init geometry */
1584	1580		m = &monitors[i];
1585	1581
1586	1582		m->screen = isxinerama ? 0 : i;
1587		-	m->root = RootWindow(dpy, m->screen);
1588	1583
1589	1584		if (mcount != 1 && isxinerama) {
1590	1585		m->sx = info[i].x_org;

1632	1627		wa.event_mask = ButtonPressMask \| ExposureMask;
1633	1628
1634	1629		/* init bars */
1635		-	m->barwin = XCreateWindow(dpy, m->root, m->sx, m->sy, m->sw, bh, 0,
	1630	+	m->barwin = XCreateWindow(dpy, root, m->sx, m->sy, m->sw, bh, 0,
1636	1631		DefaultDepth(dpy, m->screen), CopyFromParent, DefaultVisual(dpy, m->screen),
1637	1632		CWOverrideRedirect \| CWBackPixmap \| CWEventMask, &wa);
1638	1633		XDefineCursor(dpy, m->barwin, cursor[CurNormal]);
1639	1634		updatebarpos(m);
1640	1635		XMapRaised(dpy, m->barwin);
1641	1636		strcpy(stext, "dwm-"VERSION);
1642		-	m->dc.drawable = XCreatePixmap(dpy, m->root, m->sw, bh, DefaultDepth(dpy, m->screen));
1643		-	m->dc.gc = XCreateGC(dpy, m->root, 0, 0);
	1637	+	m->dc.drawable = XCreatePixmap(dpy, root, m->sw, bh, DefaultDepth(dpy, m->screen));
	1638	+	m->dc.gc = XCreateGC(dpy, root, 0, 0);
1644	1639		XSetLineAttributes(dpy, m->dc.gc, 1, LineSolid, CapButt, JoinMiter);
1645	1640		if(!m->dc.font.set)
1646	1641		XSetFont(dpy, m->dc.gc, m->dc.font.xfont->fid);
1647	1642
1648	1643		/* EWMH support per monitor */
1649		-	XChangeProperty(dpy, m->root, netatom[NetSupported], XA_ATOM, 32,
	1644	+	XChangeProperty(dpy, root, netatom[NetSupported], XA_ATOM, 32,
1650	1645		PropModeReplace, (unsigned char *) netatom, NetLast);
1651	1646
1652	1647		/* select for events */
1653	1648		wa.event_mask = SubstructureRedirectMask \| SubstructureNotifyMask
1654	1649		\| EnterWindowMask \| LeaveWindowMask \| StructureNotifyMask;
1655		-	XChangeWindowAttributes(dpy, m->root, CWEventMask \| CWCursor, &wa);
1656		-	XSelectInput(dpy, m->root, wa.event_mask);
	1650	+	XChangeWindowAttributes(dpy, root, CWEventMask \| CWCursor, &wa);
	1651	+	XSelectInput(dpy, root, wa.event_mask);
1657	1652		}
1658	1653		if(info)
1659	1654		XFree(info);

2044	2039		selectmonitor(const char *arg) {
2045	2040		Monitor *m = &monitors[arg ? atoi(arg) : (monitorat()+1) % mcount];
2046	2041
2047		-	XWarpPointer(dpy, None, m->root, 0, 0, 0, 0, m->wax+m->waw/2, m->way+m->wah/2);
	2042	+	XWarpPointer(dpy, None, root, 0, 0, 0, 0, m->wax+m->waw/2, m->way+m->wah/2);
2048	2043		focus(NULL);
2049	2044		}
2050	2045