swm

monitor.c (5287B)

---

 /*
  * Copyright (C) Raymond Cole <rc@wolog.xyz>
  *
  * Licensed under the GNU General Public License; either version 3 of
  * the License, or (at your option) any later version.  See the LICENSE
  * file for details.
  *
  * Portions of the code originally belong to dwm as developed by Anselm
  * R. Garbe et al.  See LICENSE-dwm for the copyright and license details
  * of those portions.
  */
 #include <stdlib.h>
 #include <X11/Xlib.h>
 #ifdef XINERAMA
 #include <X11/extensions/Xinerama.h>
 #endif
 
 #include "swm.h"
 #include "util.h"
 
 static Monitor *createmon(void);
 static void cleanupmon(Monitor *mon);
 static void showhide(Client *c);
 static void restack(Monitor *m);
 
 void
 wsload(Monitor *m)
 {
 	Workspace *w = m->workspaces + m->selws;
 
 	m->lyt = w->lyt;
 	w->lyt = NULL;
 	m->tagset = w->tagset;
 	updatelytdesc(m);
 }
 
 void
 wssync(Monitor *m)
 {
 	Workspace *w = m->workspaces + m->selws;
 
 	w->lyt = m->lyt;
 	w->tagset = m->tagset;
 }
 
 Monitor *
 createmon(void)
 {
 	Monitor *m;
 	unsigned i;
 
 	if (!(m = malloc(sizeof(*m)))) {
 		warn("malloc:");
 		return NULL;
 	}
 	m->nogaps = NOGAPS;
 	m->showbar = SHOWBAR;
 	m->gapih = gapih;
 	m->gapiv = gapiv;
 	m->gapoh = gapoh;
 	m->gapov = gapov;
 	m->clients = m->stack = m->sel = NULL;
 	m->next = NULL;
 	m->pending = 0;
 	for (i = 0; i < LENGTH(tags); ++i) {
 		m->workspaces[i].lyt = lytparse(defaultlayout);
 		m->workspaces[i].tagset = 1 << i;
 	}
 	m->selws = m->altws = 0;
 	wsload(m);
 	pdrawbar(m);
 	return m;
 }
 
 void
 cleanupmon(Monitor *mon)
 {
 	Monitor *m;
 	int i;
 
 	if (mon == mons) {
 		mons = mons->next;
 	} else {
 		for (m = mons; m && m->next != mon; m = m->next)
 			;
 		m->next = mon->next;
 	}
 	wssync(mon);
 	for (i = 0; i < LENGTH(tags); ++i)
 		lytfree(mon->workspaces[i].lyt);
 	XUnmapWindow(dpy, mon->barwin);
 	XDestroyWindow(dpy, mon->barwin);
 	free(mon);
 }
 
 #ifdef XINERAMA
 static int
 isuniquegeom(XineramaScreenInfo *unique, size_t n, XineramaScreenInfo *info)
 {
 	while (n--)
 		if (unique[n].x_org == info->x_org
 		 && unique[n].y_org == info->y_org
 		 && unique[n].width == info->width
 		 && unique[n].height == info->height)
 			return 0;
 	return 1;
 }
 #endif /* XINERAMA */
 
 int
 updategeom(void)
 {
 	int dirty = 0;
 
 #ifdef XINERAMA
 	if (XineramaIsActive(dpy)) {
 		XineramaScreenInfo *info;
 		Monitor *m, **pm;
 		int i, n, nn;
 		Client *c;
 
 		/* only consider unique geometries as separate screens */
 		info = XineramaQueryScreens(dpy, &n);
 		nn = 0;
 		for (i = 0; i < n; ++i)
 			if (isuniquegeom(info, nn, info + i))
 				info[nn++] = info[i];
 		for (n = 0, pm = &mons; n < nn && *pm; ++n, pm = &(*pm)->next)
 			;
 		if (n < nn) {
 			/* new monitors */
 			for (i = n; i < nn; ++i) {
 				if (!(*pm = createmon()))
 					break;
 				pm = &(*pm)->next;
 			}
 			if (i < nn) {
 				warn("cannot handle some new screens");
 				nn = i;
 			}
 		} else if (n > nn) {
 			/* removed monitors */
 			while (*pm) {
 				while ((c = (*pm)->clients)) {
 					dirty = 1;
 					sendtomon(c, mons);
 				}
 				if (*pm == selmon)
 					focusmon(mons);
 				cleanupmon(*pm);
 			}
 		}
 		for (m = mons, i = 0; m; m = m->next, ++i) {
 			if (i >= n
 			|| info[i].x_org != m->x || info[i].width != m->w
 			|| info[i].y_org != m->y || info[i].height != m->h) {
 				dirty = 1;
 				m->num = i;
 				m->x = info[i].x_org;
 				m->y = info[i].y_org;
 				m->w = info[i].width;
 				m->h = info[i].height;
 			}
 		}
 		XFree(info);
 	} else
 #endif /* XINERAMA */
 	{
 		/* default monitor setup */
 		if (!mons) {
 			if (!(mons = createmon())) {
 				warn("cannot handle default screen");
 				return -1;
 			}
 			dirty = 1;
 			mons->x = mons->y = 0;
 			mons->w = sw;
 			mons->h = sh;
 		} else if (mons->w != sw || mons->h != sh) {
 			dirty = 1;
 			mons->w = sw;
 			mons->h = sh;
 		}
 	}
 	if (dirty)
 		focusmon(mons);
 	return dirty;
 }
 
 void
 cleanupgeom(void)
 {
 	while (mons)
 		cleanupmon(mons);
 }
 
 Monitor *
 nextmon(Monitor *m)
 {
 	return m->next ? m->next : mons;
 }
 
 Monitor *
 prevmon(Monitor *m)
 {
 	Monitor *n = m == mons ? NULL : m;
 
 	for (m = mons; m->next != n; m = m->next)
 		;
 	return m;
 }
 
 Monitor *
 pttomon(int x, int y)
 {
 	Monitor *m = selmon;
 
 	do {
 		if (x >= m->x && x < m->x + m->w
 		 && y >= m->y && y < m->y + m->h)
 			return m;
 		m = m->next ? m->next : mons;
 	} while (m != selmon);
 	return NULL;
 }
 
 void
 focusmon(Monitor *m)
 {
 	if (selmon) {
 		focus(NULL);
 		pdrawbar(selmon);
 	}
 	selmon = m;
 	if (selmon) {
 		pdrawbar(selmon);
 		focus(selmon->stack);
 	}
 }
 
 void
 showhide(Client *c)
 {
 	for (; c; c = c->snext) {
 		if (c->ishidden == !ISVISIBLE(c))
 			continue;
 		if (c->ishidden) {
 			configure(c, 0);
 		} else {
 			showhide(c->snext);
 			configure(c, 0);
 			return;
 		}
 	}
 }
 
 void
 restack(Monitor *m)
 {
 	XWindowChanges fwc, twc;
 	XWindowChanges *wc = NULL;
 	Client *c;
 
 	fwc.stack_mode = twc.stack_mode = Below;
 	fwc.sibling = None;
 	twc.sibling = m->barwin;
 	for (c = m->stack; c; c = c->snext) {
 		if (c->ishidden)
 			continue;
 		if (!c->isfullscreen && m->lyt && !c->isfloating) {
 			wc = &twc;
 		} else if (fwc.sibling != None) {
 			wc = &fwc;
 		} else {
 			XRaiseWindow(dpy, c->win);
 			fwc.sibling = c->win;
 			continue;
 		}
 		XConfigureWindow(dpy, c->win, CWSibling|CWStackMode, wc);
 		wc->sibling = c->win;
 	}
 }
 
 void
 arrange(Monitor *m)
 {
 	XEvent ev;
 
 	showhide(m->stack);
 	restack(m);
 	lyttile(m);
 	XSync(dpy, False);
 	while (XCheckMaskEvent(dpy, EnterWindowMask, &ev))
 		;
 }