cwm: fix a semi-transparency border issue with some applications

When running with a compositor the border of some applications (firefox,
chromium, zathura...) is not rendered correctly.  Initializing the highest
significant bits of the color fixes it.

diff from Julien Blanchard (julien at typed-hole [dot] org); ok okan@

LICENSE

@@ -1,32 +0,0 @@
-  Copyright (c) 2004,2005 Marius Aamodt Eriksen <marius@monkey.org>
-  Copyright (c) 2004 Andy Adamson <dros@monkey.org>
-
-  Permission to use, copy, modify, and distribute this software for any
-  purpose with or without fee is hereby granted, provided that the above
-  copyright notice and this permission notice appear in all copies.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-Parts derived from 9wm:
-
-  9wm is free software, and is Copyright (c) 1994 by David Hogan.
-  Permission is granted to all sentient beings to use this software,
-  to make copies of it, and to distribute those copies, provided
-  that:
-
-      (1) the copyright and licence notices are left intact
-      (2) the recipients are aware that it is free software
-      (3) any unapproved changes in functionality are either
-            (i) only distributed as patches
-        or (ii) distributed as a new program which is not called 9wm
-                and whose documentation gives credit where it is due
-      (4) the author is not held responsible for any defects
-          or shortcomings in the software, or damages caused by it.
-
-  There is no warranty for this software.  Have a nice day.

Makefile

@@ -1,23 +1,22 @@
 # $OpenBSD$
 
-.include <bsd.own.mk>
-
-X11BASE?=	/usr/X11R6
+.include <bsd.xconf.mk>
 
 PROG=		cwm
 
-SRCS=		calmwm.c draw.c screen.c xmalloc.c client.c grab.c search.c \
-		util.c xutil.c conf.c input.c xevents.c group.c geographic.c \
-		kbfunc.c cursor.c font.c
+SRCS=		calmwm.c screen.c xmalloc.c client.c menu.c \
+		search.c util.c xutil.c conf.c xevents.c group.c \
+		kbfunc.c parse.y
 
-CPPFLAGS+=	-I${X11BASE}/include -I${X11BASE}/include/freetype2
+CPPFLAGS+=	-I${X11BASE}/include -I${X11BASE}/include/freetype2 -I${.CURDIR}
 
-LDADD+=		-L${X11BASE}/lib -lXft -lXrender -lX11 -lXau -lXdmcp \
-		-lfontconfig -lexpat -lfreetype -lz -lX11 -lXau -lXdmcp -lXext
+CFLAGS+=	-Wall
+YFLAGS=
+LDADD+=		-L${X11BASE}/lib -lXft -lXrender -lX11 -lxcb -lXau -lXdmcp \
+		-lfontconfig -lexpat -lfreetype -lz -lXrandr -lXext
 
-MANDIR=		${X11BASE}/man/cat
-
-CLEANFILES=	cwm.cat1
+MANDIR=		${X11BASE}/man/man
+MAN=		cwm.1 cwmrc.5
 
 obj: _xenocara_obj
 

README

@@ -1,59 +0,0 @@
---------------------------------------------------------------------------------
-cwm release three
---------------------------------------------------------------------------------
-   by Marius Aamodt Eriksen <marius@monkey.org>
-   contributions by Andy Adamson <dros@monkey.org>,
-                    Niels Provos <provos@monkey.org>,
-                    Martin Murray <mmurray@monkey.org>,
-                    Dimitris Economou <dimeco@stanford.edu> &
-                    Antti Nyk<79>nen <aon@iki.fi>.
-
-   http://monkey.org/~marius/cwm
-
-DESCRIPTION
-
-   cwm is a window manager initially inspired by evilwm[1].  It
-   developed out of modifications to evilwm, but eventually the code
-   base of evilwm did not accomodate well for the new features added.
-   So calmwm was written from scratch.
-
-   Its main goal is to be as efficient as possible, while providing 
-   a very clean, simple & attractive aesthetic.
-
-   cwm has several novel features, including the ability to search
-   for windows.
-
-HIGHLIGHTS IN RELEASE TWO
-
-   * Improved alt-tabbing, including the ability to reverse cycle.
-   * Display of a context menu when alt-tabbing, showing the previous,
-     current and next window in the cycle order.
-   * Much improved ranking in search.
-   * In search-menus, the ability to list every item.
-
-HIGHLIGHTS IN RELEASE THREE
-
-   * More search ranking improvements
-   * Many contributions by Antti Nyk<79>nen: keyboard binding "i18n",
-     show window labels in minimized window menu, automatic window
-     grouping, MWM hints support & some bug fixes.
-   * Xft support & the addition of the -f flag (see manpage).
-
-INSTALL
-
-   ./configure
-   make
-   su
-   make install
-
-DOCUMENTATION
-
-   See the manpage cwm(1).
-
-LICENSE
-
-   cwm is distributed under a BSD like license.  Feel free to use,
-   modify and distribute in any form.  See the LICENSE file for more
-   information.
-
-[1] http://evilwm.sourceforge.net/

TODO

@@ -1,30 +0,0 @@
-- clean up menu code from 9wm
-
-- window initial position
-
-- don't map windows if it's within [some time increment] of active typing,
-  this is part of the "calm" goal.  also, it helps if you're mindlessly
-  typing in a password and the keyboard input ends up in some other window,
-  bad...
-
-- integrate everything into /ONE/ event loop.
-  register handlers, with the ability to select, for example,
-  a window, or an event, etc.  (no, maybe not...)
-
-- ignoreq, always lower them.  perhaps implement by lowering the entire 
-  queue on each XLower...
-
-- search window should try to stay inside of the screen boundaries.
-
-- geographical keyboard navigation (window switching)
-
-- search should ignore the current window. (not add to match list).
-
-- make kbd shortcuts/events more general.  the ability to associate an
-  event with a mode (i.e. prioritize).  gets rid of hacky-ness in
-  groups, etc.
-
-- figure out what's up when alt-tab goes back to the current window
-  once before moving on.
-
-- cache all the atoms somewhere.

calmwm.c

@@ -2,351 +2,236 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <sys/wait.h>
+
+#include <err.h>
+#include <errno.h>
+#include <getopt.h>
+#include <limits.h>
+#include <locale.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-Display				*X_Dpy;
-XFontStruct			*X_Font;
+Display			*X_Dpy;
+Time			 Last_Event_Time = CurrentTime;
+Atom			 cwmh[CWMH_NITEMS];
+Atom			 ewmh[EWMH_NITEMS];
+struct screen_q		 Screenq = TAILQ_HEAD_INITIALIZER(Screenq);
+struct conf		 Conf;
+volatile sig_atomic_t	 cwm_status;
 
-Cursor				 Cursor_move;
-Cursor				 Cursor_resize;
-Cursor				 Cursor_select;
-Cursor				 Cursor_default;
-Cursor				 Cursor_question;
-
-struct screen_ctx_q		 Screenq;
-struct screen_ctx		*Curscreen;
-u_int				 Nscreens;
-
-struct client_ctx_q		 Clientq;
-
-int				 Doshape, Shape_ev;
-int				 Starting;
-struct conf			 Conf;
-struct fontdesc                 *DefaultFont;
-char                            *DefaultFontName;
-
-/* From TWM */
-#define gray_width 2
-#define gray_height 2
-static char gray_bits[] = {0x02, 0x01};
-
-/* List borrowed from 9wm/rio */
-char *tryfonts[] = {
-	"9x15bold",
-	"blit",
-	"*-lucidatypewriter-bold-*-14-*-75-*",
-	"*-lucidatypewriter-medium-*-12-*-75-*",
-	"fixed",
-	"*",
-	NULL,
-};
-
-static void _sigchld_cb(int);
+__dead void	usage(void);
+static void	sighdlr(int);
+static int	x_errorhandler(Display *, XErrorEvent *);
+static int	x_init(const char *);
+static void	x_teardown(void);
+static int	x_wmerrorhandler(Display *, XErrorEvent *);
 
 int
 main(int argc, char **argv)
 {
-	int ch;
-	int conf_flags = 0;
+	char		*display_name = NULL;
+	char		*fallback;
+	int		 ch, xfd, nflag = 0;
+	struct pollfd	 pfd[1];
 
-	char *display_name = NULL;
+	if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
+		warnx("no locale support");
+	mbtowc(NULL, NULL, MB_CUR_MAX);
 
-	DefaultFontName = "sans-serif:pixelsize=14:bold";
+	conf_init(&Conf);
 
-	while ((ch = getopt(argc, argv, "d:sf:")) != -1) {
+	fallback = u_argv(argv);
+	Conf.wm_argv = u_argv(argv);
+	while ((ch = getopt(argc, argv, "c:d:nv")) != -1) {
 		switch (ch) {
+		case 'c':
+			free(Conf.conf_file);
+			Conf.conf_file = xstrdup(optarg);
+			break;
 		case 'd':
 			display_name = optarg;
 			break;
-		case 's':
-			conf_flags |= CONF_STICKY_GROUPS;
+		case 'n':
+			nflag = 1;
 			break;
-		case 'f':
-			DefaultFontName = xstrdup(optarg);
+		case 'v':
+			Conf.debug++;
 			break;
 		default:
-			errx(1, "Unknown option '%c'", ch);
+			usage();
 		}
 	}
 	argc -= optind;
 	argv += optind;
 
-	/* Ignore a few signals. */
-        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
-                err(1, "signal");
+	if (signal(SIGCHLD, sighdlr) == SIG_ERR ||
+	    signal(SIGHUP, sighdlr) == SIG_ERR ||
+	    signal(SIGINT, sighdlr) == SIG_ERR ||
+	    signal(SIGTERM, sighdlr) == SIG_ERR)
+		err(1, "signal");
 
-        if (signal(SIGCHLD, _sigchld_cb) == SIG_ERR)
-                err(1, "signal");
+	if (parse_config(Conf.conf_file, &Conf) == -1) {
+		warnx("error parsing config file");
+		if (nflag)
+			return 1;
+	}
+	if (nflag)
+		return 0;
 
-	group_init();
+	xfd = x_init(display_name);
+	cwm_status = CWM_RUNNING;
 
-	Starting = 1;
-	conf_setup(&Conf);
-	Conf.flags |= conf_flags;
-	client_setup();
-	x_setup(display_name);
-	Starting = 0;
+	if (pledge("stdio rpath proc exec", NULL) == -1)
+		err(1, "pledge");
 
-	xev_init();
-	XEV_QUICK(NULL, NULL, MapRequest, xev_handle_maprequest, NULL);
-	XEV_QUICK(NULL, NULL, UnmapNotify, xev_handle_unmapnotify, NULL);
-	XEV_QUICK(NULL, NULL, ConfigureRequest,
-	    xev_handle_configurerequest, NULL);
-	XEV_QUICK(NULL, NULL, PropertyNotify, xev_handle_propertynotify, NULL);
-	XEV_QUICK(NULL, NULL, EnterNotify, xev_handle_enternotify, NULL);
-	XEV_QUICK(NULL, NULL, LeaveNotify, xev_handle_leavenotify, NULL);
-	XEV_QUICK(NULL, NULL, ButtonPress, xev_handle_buttonpress, NULL);
-	XEV_QUICK(NULL, NULL, ButtonRelease, xev_handle_buttonrelease, NULL);
-	XEV_QUICK(NULL, NULL, KeyPress, xev_handle_keypress, NULL);
-	XEV_QUICK(NULL, NULL, KeyRelease, xev_handle_keyrelease, NULL);
-	XEV_QUICK(NULL, NULL, Expose, xev_handle_expose, NULL);
-	XEV_QUICK(NULL, NULL, DestroyNotify, xev_handle_destroynotify, NULL);
-	XEV_QUICK(NULL, NULL, ClientMessage, xev_handle_clientmessage, NULL);
+	memset(&pfd, 0, sizeof(pfd));
+	pfd[0].fd = xfd;
+	pfd[0].events = POLLIN;
+	while (cwm_status == CWM_RUNNING) {
+		xev_process();
+		if (poll(pfd, 1, INFTIM) == -1) {
+			if (errno != EINTR)
+				warn("poll");
+		}
+	}
+	x_teardown();
+	if (cwm_status == CWM_EXEC_WM) {
+		u_exec(Conf.wm_argv);
+		warnx("'%s' failed to start, starting fallback", Conf.wm_argv);
+		u_exec(fallback);
+	}
 
-	xev_loop();
-
-	return (0);
+	return 0;
 }
 
-void
-x_setup(char *display_name)
+static int
+x_init(const char *dpyname)
 {
-	int i;
-	struct screen_ctx *sc;
-	char *fontname;
+	int	i;
 
-	TAILQ_INIT(&Screenq);
-
-	if ((X_Dpy = XOpenDisplay(display_name)) == NULL)
-		errx(1, "%s:%d XOpenDisplay()", __FILE__, __LINE__);
+	if ((X_Dpy = XOpenDisplay(dpyname)) == NULL)
+		errx(1, "unable to open display \"%s\"", XDisplayName(dpyname));
 
+	XSetErrorHandler(x_wmerrorhandler);
+	XSelectInput(X_Dpy, DefaultRootWindow(X_Dpy), SubstructureRedirectMask);
+	XSync(X_Dpy, False);
 	XSetErrorHandler(x_errorhandler);
 
-	Doshape = XShapeQueryExtension(X_Dpy, &Shape_ev, &i);
+	Conf.xrandr = XRRQueryExtension(X_Dpy, &Conf.xrandr_event_base, &i);
 
-	i = 0;
-	while ((fontname = tryfonts[i++]) != NULL) {
-		if ((X_Font = XLoadQueryFont(X_Dpy, fontname)) != NULL)
-			break;
-	}
+	xu_atom_init();
+	conf_cursor(&Conf);
 
-	if (fontname == NULL)
-		errx(1, "Couldn't load any fonts.");
+	for (i = 0; i < ScreenCount(X_Dpy); i++)
+		screen_init(i);
 
-	Nscreens = ScreenCount(X_Dpy);
-	for (i = 0; i < (int)Nscreens; i++) {
-		XMALLOC(sc, struct screen_ctx);
-		x_setupscreen(sc, i);
-		TAILQ_INSERT_TAIL(&Screenq, sc, entry);
-	}
-
-	Cursor_move = XCreateFontCursor(X_Dpy, XC_fleur);
-	Cursor_resize = XCreateFontCursor(X_Dpy, XC_bottom_right_corner);
-	/* (used to be) XCreateFontCursor(X_Dpy, XC_hand1); */
-	Cursor_select = XCreateFontCursor(X_Dpy, XC_hand1);
-/* 	Cursor_select = cursor_bigarrow(Curscreen); */
-	Cursor_default = XCreateFontCursor(X_Dpy, XC_X_cursor);
-/* 	Cursor_default = cursor_bigarrow(Curscreen); */
-	Cursor_question = XCreateFontCursor(X_Dpy, XC_question_arrow);
-}
-
-int
-x_setupscreen(struct screen_ctx *sc, u_int which)
-{
-	XColor tmp;
-	XGCValues gv, gv1/* , gv2 */;
-	Window *wins, w0, w1;
-	u_int nwins, i = 0;
-	XWindowAttributes winattr;
-	XSetWindowAttributes rootattr;
-	struct keybinding *kb;
-
-	sc->display = x_screenname(which);
-	sc->which = which;
-	sc->rootwin = RootWindow(X_Dpy, which);
-	XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, which),
-	    "black", &sc->fgcolor, &tmp);
-	XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, which),
-	    "#00cc00", &sc->bgcolor, &tmp);
-	XAllocNamedColor(X_Dpy,DefaultColormap(X_Dpy, which),
-	    "blue", &sc->fccolor, &tmp);
-	XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, which),
-	    "red", &sc->redcolor, &tmp);
-	XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, which),
-	    "#00ccc8", &sc->cyancolor, &tmp);
-	XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, which),
-	    "white", &sc->whitecolor, &tmp);
-	XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, which),
-	    "black", &sc->blackcolor, &tmp);
-
-	TAILQ_FOREACH(kb, &Conf.keybindingq, entry)
-		xu_key_grab(sc->rootwin, kb->modmask, kb->keysym);
-
-	/* Special -- for alt state. */
-/* 	xu_key_grab(sc->rootwin, 0, XK_Alt_L); */
-/* 	xu_key_grab(sc->rootwin, 0, XK_Alt_R); */
-
-	sc->blackpixl = BlackPixel(X_Dpy, sc->which);
-	sc->whitepixl = WhitePixel(X_Dpy, sc->which);
-	sc->bluepixl = sc->fccolor.pixel;
-	sc->redpixl = sc->redcolor.pixel;
-	sc->cyanpixl = sc->cyancolor.pixel;
-
-        sc->gray = XCreatePixmapFromBitmapData(X_Dpy, sc->rootwin,
-            gray_bits, gray_width, gray_height,
-            sc->blackpixl, sc->whitepixl, DefaultDepth(X_Dpy, sc->which));
-
-        sc->blue = XCreatePixmapFromBitmapData(X_Dpy, sc->rootwin,
-            gray_bits, gray_width, gray_height,
-            sc->bluepixl, sc->whitepixl, DefaultDepth(X_Dpy, sc->which));
-
-        sc->red = XCreatePixmapFromBitmapData(X_Dpy, sc->rootwin,
-            gray_bits, gray_width, gray_height,
-	    sc->redpixl, sc->whitepixl, DefaultDepth(X_Dpy, sc->which));
-
-	gv.foreground = sc->blackpixl^sc->whitepixl;
-	gv.background = sc->whitepixl;
-	gv.function = GXxor;
-	gv.line_width = 1;
-	gv.subwindow_mode = IncludeInferiors;
-	gv.font = X_Font->fid;
-
-	sc->gc = XCreateGC(X_Dpy, sc->rootwin,
-	    GCForeground|GCBackground|GCFunction|
-	    GCLineWidth|GCSubwindowMode|GCFont, &gv);
-
-#ifdef notyet
-	gv2.foreground = sc->blackpixl^sc->cyanpixl;
-	gv2.background = sc->cyanpixl;
-	gv2.function = GXxor;
-	gv2.line_width = 1;
-	gv2.subwindow_mode = IncludeInferiors;
-	gv2.font = X_Font->fid;
-#endif
-
-	sc->hlgc = XCreateGC(X_Dpy, sc->rootwin,
-	    GCForeground|GCBackground|GCFunction|
-	    GCLineWidth|GCSubwindowMode|GCFont, &gv);
-
-	gv1.function = GXinvert;
-	gv1.subwindow_mode = IncludeInferiors;
-	gv1.line_width = 1;
-	gv1.font = X_Font->fid;
-
-	sc->invgc = XCreateGC(X_Dpy, sc->rootwin,
-	    GCFunction|GCSubwindowMode|GCLineWidth|GCFont, &gv1);
-
-	font_init(sc);
-	DefaultFont = font_getx(sc, DefaultFontName);
-
-	/*
-	 * XXX - this should *really* be in screen_init().  ordering
-	 * problem.
-	 */
-	TAILQ_INIT(&sc->mruq);
-
-	/* Initialize menu window. */
-	grab_menuinit(sc);
-	search_init(sc);
-
-	/* Deal with existing clients. */
-	XQueryTree(X_Dpy, sc->rootwin, &w0, &w1, &wins, &nwins);	
-
-	for (i = 0; i < nwins; i++) {
-		XGetWindowAttributes(X_Dpy, wins[i], &winattr);
-		if (winattr.override_redirect ||
-		    winattr.map_state != IsViewable) {
-			char *name;
-			XFetchName(X_Dpy, wins[i], &name);
-			continue;
-		}
-		client_new(wins[i], sc, winattr.map_state != IsUnmapped);
-	}
-	XFree(wins);
-
-	Curscreen = sc;	/* XXX */
-	screen_init();
-	screen_updatestackingorder();
-
-	rootattr.event_mask = ChildMask|PropertyChangeMask|EnterWindowMask|
-	    LeaveWindowMask|ColormapChangeMask|ButtonMask;
-
-	/* Set the root cursor to a nice obnoxious arrow :-) */
-/* 	rootattr.cursor = cursor_bigarrow(sc); */
-
-	XChangeWindowAttributes(X_Dpy, sc->rootwin,
-	    /* CWCursor| */CWEventMask, &rootattr);
-
-	XSync(X_Dpy, False);
-
-	return (0);
-}
-
-char *
-x_screenname(int which)
-{
-	char *cp, *dstr, *sn;
-	size_t snlen;
-
-	if (which > 9)
-		errx(1, "Can't handle more than 9 screens.  If you need it, "
-		    "tell <marius@monkey.org>.  It's a trivial fix.");
-
-	dstr = xstrdup(DisplayString(X_Dpy));
-
-	if ((cp = rindex(dstr, ':')) == NULL)
-		return (NULL);
-
-	if ((cp = index(cp, '.')) != NULL)
-		*cp = '\0';
-
-	snlen = strlen(dstr) + 3; /* string, dot, number, null */
-	sn = (char *)xmalloc(snlen);
-	snprintf(sn, snlen, "%s.%d", dstr, which);
-	free(dstr);
-
-	return (sn);
-}
-
-int
-x_errorhandler(Display *dpy, XErrorEvent *e)
-{
-#ifdef DEBUG
-	{
-		char msg[80], number[80], req[80];
-
-		XGetErrorText(X_Dpy, e->error_code, msg, sizeof(msg));
-		snprintf(number, sizeof(number), "%d", e->request_code);
-		XGetErrorDatabaseText(X_Dpy, "XRequest", number,
-		    "<unknown>", req, sizeof(req));
-
-		warnx("%s(0x%x): %s", req, (u_int)e->resourceid, msg);
-	}
-#endif
-
-	if (Starting && 
-	    e->error_code == BadAccess &&                                       
-	    e->request_code == X_GrabKey)                        
-		errx(1, "root window unavailable - perhaps another "
-		    "wm is running?");                                      
-
-	return (0);
+	return ConnectionNumber(X_Dpy);
 }
 
 static void
-_sigchld_cb(int which)
+x_teardown(void)
 {
-	pid_t pid;
-	int status;
+	struct screen_ctx	*sc;
+	unsigned int		 i;
 
-/* 	Collect dead children. */
-        while ((pid = waitpid(-1, &status, WNOHANG)) > 0 ||
-            (pid < 0 && errno == EINTR))
-		;
+	conf_clear(&Conf);
+
+	TAILQ_FOREACH(sc, &Screenq, entry) {
+		for (i = 0; i < CWM_COLOR_NITEMS; i++)
+			XftColorFree(X_Dpy, DefaultVisual(X_Dpy, sc->which),
+			    DefaultColormap(X_Dpy, sc->which),
+			    &sc->xftcolor[i]);
+		XftFontClose(X_Dpy, sc->xftfont);
+		XUngrabKey(X_Dpy, AnyKey, AnyModifier, sc->rootwin);
+	}
+	XUngrabPointer(X_Dpy, CurrentTime);
+	XUngrabKeyboard(X_Dpy, CurrentTime);
+	for (i = 0; i < CF_NITEMS; i++)
+		XFreeCursor(X_Dpy, Conf.cursor[i]);
+	XSync(X_Dpy, False);
+	XSetInputFocus(X_Dpy, PointerRoot, RevertToPointerRoot, CurrentTime);
+	XCloseDisplay(X_Dpy);
+}
+
+static int
+x_wmerrorhandler(Display *dpy, XErrorEvent *e)
+{
+	errx(1, "root window unavailable - perhaps another wm is running?");
+	return 0;
+}
+
+static int
+x_errorhandler(Display *dpy, XErrorEvent *e)
+{
+#ifdef DEBUG
+	char msg[80], number[80], req[80];
+
+	XGetErrorText(X_Dpy, e->error_code, msg, sizeof(msg));
+	(void)snprintf(number, sizeof(number), "%d", e->request_code);
+	XGetErrorDatabaseText(X_Dpy, "XRequest", number,
+	    "<unknown>", req, sizeof(req));
+
+	warnx("%s(0x%x): %s", req, (unsigned int)e->resourceid, msg);
+#endif
+	return 0;
+}
+
+static void
+sighdlr(int sig)
+{
+	pid_t	 pid;
+	int	 save_errno = errno, status;
+
+	switch (sig) {
+	case SIGCHLD:
+		/* Collect dead children. */
+		while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) > 0 ||
+		    (pid < 0 && errno == EINTR))
+			;
+		break;
+	case SIGHUP:
+		cwm_status = CWM_EXEC_WM;
+		break;
+	case SIGINT:
+	case SIGTERM:
+		cwm_status = CWM_QUIT;
+		break;
+	}
+
+	errno = save_errno;
+}
+
+__dead void
+usage(void)
+{
+	extern char	*__progname;
+
+	(void)fprintf(stderr, "usage: %s [-nv] [-c file] [-d display]\n",
+	    __progname);
+	exit(1);
 }

cursor.c

@@ -1,65 +0,0 @@
-/*
- * cursor.c
- *
- * Copyright (c) 2005 Marius Eriksen <marius@monkey.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "headers.h"
-#include "calmwm.h"
-
-/* Pretty much straight out of 9wm... */
-
-struct cursor_data {
-	int width;
-	int hot[2];
-	u_char mask[64];
-	u_char fore[64];
-};
-
-static struct cursor_data Bigarrow = {
-	16,
-	{0, 0},
-	{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x3F, 
-	  0xFF, 0x0F, 0xFF, 0x0F, 0xFF, 0x1F, 0xFF, 0x3F, 
-	  0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x3F, 
-	  0xCF, 0x1F, 0x8F, 0x0F, 0x07, 0x07, 0x03, 0x02, 
-	},
-	{ 0x00, 0x00, 0xFE, 0x7F, 0xFE, 0x3F, 0xFE, 0x0F, 
-	  0xFE, 0x07, 0xFE, 0x07, 0xFE, 0x0F, 0xFE, 0x1F, 
-	  0xFE, 0x3F, 0xFE, 0x7F, 0xFE, 0x3F, 0xCE, 0x1F, 
-	  0x86, 0x0F, 0x06, 0x07, 0x02, 0x02, 0x00, 0x00, 
-	},
-};
-
-static Cursor
-_mkcursor(struct cursor_data *c, struct screen_ctx *sc)
-{
-	Pixmap f, m;
-
-	f = XCreatePixmapFromBitmapData(X_Dpy, sc->rootwin, (char *)c->fore,
-	    c->width, c->width, 1, 0, 1);
-	m = XCreatePixmapFromBitmapData(X_Dpy, sc->rootwin, (char *)c->mask,
-	    c->width, c->width, 1, 0, 1);
-
-	return (XCreatePixmapCursor(X_Dpy, f, m,
-		&sc->blackcolor, &sc->whitecolor, c->hot[0], c->hot[1]));
-}
-
-Cursor
-cursor_bigarrow(struct screen_ctx *sc)
-{
-	return _mkcursor(&Bigarrow, sc);
-}
-

cwm.1

@@ -1,7 +1,20 @@
 .\"	$OpenBSD$
 .\"
-.\" The following requests are required for all man pages.
-.Dd June 29, 2007
+.\" Copyright (c) 2004,2005 Marius Aamodt Eriksen <marius@monkey.org>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd $Mdocdate$
 .Dt CWM 1
 .Os
 .Sh NAME
@@ -10,136 +23,184 @@
 .Sh SYNOPSIS
 .\" For a program:  program [-abc] file ...
 .Nm cwm
-.Op Fl s
+.Op Fl nv
+.Op Fl c Ar file
 .Op Fl d Ar display
-.Op Fl f Ar fontname
 .Sh DESCRIPTION
 .Nm
-is a window manager for X11.
-It was originally inspired by evilwm, but was rewritten from scratch
-due to limitations in the evilwm codebase.
-The from-scratch rewrite borrowed some code from 9wm.
-.Nm
-contains many new features which all concentrate on the efficiency and
-transparency of window management.
-.Nm
-also aims to maintain the most simplest and pleasant aesthetic.
+is a window manager for X11 which contains many features that
+concentrate on the efficiency and transparency of window management,
+while maintaining the simplest and most pleasant aesthetic.
 .Pp
-The following notation is used throughout this page:
-.Pp
-.Bl -tag -width Ds -offset indent -compact
-.It Ic C
-Control
-.It Ic M
-Meta (Alt on PCs)
-.It Ic S
-Shift
-.It Ic M1
-Left mouse button
-.It Ic M2
-Middle mouse button
-.It Ic M3
-Right mouse button
+The options are as follows:
+.Bl -tag -width Ds
+.It Fl c Ar file
+Specify an alternative configuration file.
+By default,
+.Nm
+loads
+.Pa ~/.cwmrc ,
+if present.
+Any error messages from lines in the configuration file will be sent to
+.Em stderr ;
+however,
+.Nm
+will continue to process the rest of the configuration file.
+.It Fl d Ar display
+Specify the display to use.
+.It Fl n
+Configtest mode.
+Only check the configuration file for validity.
+.It Fl v
+Verbose mode.
+Multiple
+.Fl v
+options increase the verbosity.
 .El
 .Pp
 .Nm
-is very simple in its use.
-Most of the actions are initiated via keybindings.
-The current keybindings are described below;
-their functionality is described in more detail later.
+actions are initiated either via key or mouse bindings.
+The following notations are used throughout this page:
 .Pp
-.Bl -tag -width "C-M-EscapeXXX" -offset indent -compact
-.It Ic C-M-Enter
+.Bl -tag -width Ds -offset indent -compact
+.It Ic C
+Control key.
+.It Ic M
+Meta key.
+.It Ic S
+Shift key.
+.It Ic 4
+Mod4 (windows) key.
+.It Ic M1
+Left mouse button.
+.It Ic M2
+Middle mouse button.
+.It Ic M3
+Right mouse button.
+.El
+.Pp
+The default key bindings are:
+.Pp
+.Bl -tag -width "CM-EscapeXXXXX" -offset indent -compact
+.It Ic CM-Return
 Spawn a new terminal.
-.It Ic C-M-Delete
+.It Ic CM-Delete
 Lock the screen.
-.It Ic M-Enter
+.It Ic M-Return
 Hide current window.
 .It Ic M-Down
 Lower current window.
 .It Ic M-Up
 Raise current window.
-.It Ic M-/
+.It Ic M-slash
 Search for windows.
-.It Ic C-/
+.It Ic C-slash
 Search for applications.
-.It Ic C-M-l
+.It Ic CM-n
 Label current window.
 .It Ic M-Tab
 Cycle through currently visible windows.
-.It Ic M-S-Tab
+.It Ic MS-Tab
 Reverse cycle through currently visible windows.
-.It Ic C-M-x
-Delete current window.
-.It Ic C-M-Escape
-Enter group edit mode.
-.It Ic C-M-[n]
-Select group n, where n is 1-9.
-.It Ic C-M-0
-Select all groups.
+.It Ic CM-x
+Close current window.
+.It Ic CM-[n]
+Toggle visibility of group n, where n is 1-9.
+.It Ic CM-a
+Toggle visibility of all groups.
+.It Ic CM-g
+Toggle group membership of current window.
 .It Ic M-Right
-Switch to next group.
+Cycle through active groups.
 .It Ic M-Left
-Switch to previous group.
-.It Ic C-M-f
-Toggle full-screen size of window.
-.It Ic C-M-=
-Toggle vertical maximization of window.
-.It Ic M-?
+Reverse cycle through active groups.
+.It Ic CMS-f
+Toggle freezing geometry of current window.
+.It Ic CM-s
+Toggle stickiness of current window.
+.It Ic CM-f
+Toggle full-screen mode of current window.
+.It Ic CM-m
+Toggle maximization of current window.
+.It Ic CM-equal
+Toggle vertical maximization of current window.
+.It Ic CMS-equal
+Toggle horizontal maximization of current window.
+.It Ic M-[hjkl]
+Move window by a small amount.
+.It Ic MS-[hjkl]
+Move window by a large amount; see
+.Xr cwmrc 5 .
+.It Ic CM-[hjkl]
+Resize window by a small amount.
+.It Ic CMS-[hjkl]
+Resize window by a large amount; see
+.Xr cwmrc 5 .
+.It Ic M-question
 Spawn
-.Dq Exec program
+.Dq exec program
 dialog.
-.It Ic M-.
+.It Ic M-period
 Spawn
-.Dq Ssh to
+.Dq ssh to
 dialog.
 This parses
 .Pa $HOME/.ssh/known_hosts
 to provide host auto-completion.
 .Xr ssh 1
 will be executed via the configured terminal emulator.
+.It Ic CM-w
+Spawn
+.Dq exec WindowManager
+menu, allowing a switch to another window manager.
+.It Ic CMS-r
+Restart.
+.It Ic CMS-q
+Quit.
 .El
 .Pp
-The mouse bindings are also important, they are:
+The default mouse bindings are:
 .Pp
-.Bl -tag -width Ds -offset indent -compact
-.It M-M1
-Move a window.
-.It C-M-M1
-Toggle a window's membership in the current group.
-A blue highlight indicates the window has been added to the group;
-a red highlight indicates it has been removed.
-.It M-M2
-Resize a window/select a window.
-.It M-M3
-Lower a window.
+.Bl -tag -width "CM-EscapeXXXXX" -offset indent -compact
+.It Ic M-M1
+Move current window.
+.It Ic CM-M1
+Toggle group membership of current window.
+.It Ic M-M2
+Resize current window
+.It Ic M-M3
+Lower current window.
+.It Ic CMS-M3
+Hide current window.
+.El
+.Pp
+The following key bindings may be used to navigate
+search and exec dialogs:
+.Pp
+.Bl -tag -width "[Down] or C-s or M-j" -offset indent -compact
+.It Ic [Return]
+Select item.
+.It Ic [Down], C-s No or Ic M-j
+Next item.
+.It Ic [Up], C-r No or Ic M-k
+Previous item.
+.It Ic [Backspace] No or Ic C-h
+Backspace.
+.It Ic C-u
+Clear input.
+.It Ic C-a
+List all available items.
+.It Ic [Esc]
+Cancel.
 .El
 .Pp
-The options for
 .Nm
-are as follows:
-.Bl -tag -width Ds
-.It Fl d Ar display
-Specify the display to use.
-.It Fl f Ar fontname
-Makes the
-.Xr Xft 3
-font string
-.Ar fontname
-the default font.
-.It Fl s
-Set sticky group mode on.
-The default behavior for new windows is to not assign any group.
-This changes the default behavior to assigning the currrently selected
-group to any newly created windows.
-.El
-.Sh WINDOW MOVEMENT
-.Nm
-windows can be moved with the use of the keyboard through Vi-like bindings.
-M-[hjkl] moves the current window a small amount, while M-shift-[hjkl] moves
-the current window a larger amount.
-For example, to move the current window to the left a small amount, press M-h.
-To move the current window down by a larger amount, press M-shift-j.
+rereads its configuration file when it receives a hangup signal,
+.Dv SIGHUP ,
+by executing itself with the name and arguments with which it was started.
+This is equivalent to the
+.Ar restart
+function.
 .Sh SEARCH
 .Nm
 features the ability to search for windows by their current title,
@@ -152,61 +213,45 @@ keeps a history of the 5 previous titles of a window.
 When searching, the leftmost character of the result list may show a
 flag:
 .Pp
-.Bl -tag -width 10n -offset -indent -compact
+.Bl -tag -width Ds -offset indent -compact
 .It !
-The window is the currently focused window.
+Window is currently focused.
 .It &
-The window is hidden.
-.El
-.Pp
-The following keybindings may be used to navigate the result list:
-.Pp
-.Bl -tag -width "[Down] or C-sXXX" -offset indent -compact
-.It Ic [Down] No or Ic C-s
-Select the next window in the list.
-.It Ic [Up] No or Ic C-r
-Select the previous window in the list.
-.It Ic C-u
-Clear the input.
-.It Ic [Enter]
-Focus the selected window.
-.It Ic [Esc]
-Quit.
-.It Ic C-a
-Whenever there are no matching windows, list every window.
+Window is hidden.
 .El
+.Sh APPLICATIONS
+.Nm
+manages a list of applications defined with the
+.Cm command
+configuration option.
 .Sh GROUPS
 .Nm
 has the ability to group windows together, and use the groups to
 perform operations on the entire group instead of just one window.
-Currently, the only operation that is supported is to hide and unhide
-the grouped windows.
 Together with the
-.Fl s
+.Pa sticky
 option, this can be used to emulate virtual desktops.
 .Pp
-To edit groups, enter the group edit mode, and select/unselect the
-groups with the group selection mouse click.
-A blue border will be shown on the currently selected windows.
-The group selection keyboard shortcuts can also be used to change
-which group to edit.
+To edit groups, use the group selection commands to toggle membership
+of a group.
+A blue border will be shown briefly on windows added to the current group,
+and a red border will be shown on those just removed.
 .Sh MENUS
 Menus are recalled by clicking the mouse on the root window:
 .Pp
-.Bl -tag -width 10n -offset -indent -compact
-.It M1
-Show list of currently hidden windows.
-Clicking on an item will unhide that window.
-.It M2
+.Bl -tag -width Ds -offset indent -compact
+.It Ic M1
+Show list of currently defined windows.
+Selecting an item will warp to that window, unhiding it if necessary.
+.It Ic M2
 Show list of currently defined groups.
-Clicking on an item will hide/unhide that group.
-.It M3
-Show list of applications as defined in
-.Pa ~/.calmwm .
-Clicking on an item will spawn that application.
+Selecting an item will hide/unhide that group.
+.It Ic M3
+Show list of applications as defined in the configuration file.
+Selecting an item will spawn that application.
 .El
 .Sh ENVIRONMENT
-.Bl -tag -width "DISPLAYXXX"
+.Bl -tag -width "DISPLAYXXX" -compact
 .It DISPLAY
 .Nm
 starts on this display unless the
@@ -214,63 +259,32 @@ starts on this display unless the
 option is given.
 .El
 .Sh FILES
-.Bl -tag -width Ds
-.It Pa ~/.calmwm
-Any directory entries here are shown in the application menu.
-When it is selected, the image is executed with
-.Xr execve 2 .
-One use of this is to create symbolic links for your favorite
-applications in this directory using
-.Xr ln 1 .
-.Pp
-The entries
-.Nm term
-and
-.Nm lock
-have a special meaning.
-When they exist they point to the terminal program and screen locking
-programs used by the keybindings specified above.
-The defaults for these are
-.Xr xterm 1
-and
-.Xr xlock 1 ,
-respectively.
-.It Pa ~/.calmwm/.autogroup
-Symlinks in this directory are read upon startup and control the
-automatic grouping feature, which is based on the window name and class
-properties.
-To obtain the name and class of a window, use
-.Ql xprop WM_CLASS ,
-then click on the window.
-The first quoted string is the window name; the second one is the
-window class.
-.Pp
-The name of a link can be the window class, or the window class and name
-separated by a comma.
-The link target is a group name (one, two, \&..., nine).
-For example, to make all windows in the
-.Xr xterm 1
-class go to the third group:
-.Bd -literal -offset indent
-$ ln -s three ~/.calmwm/.autogroup/XTerm
-.Ed
+.Bl -tag -width "~/.cwmrcXX" -compact
+.It Pa ~/.cwmrc
+Default
+.Nm
+configuration file.
 .El
+.Sh SEE ALSO
+.Xr cwmrc 5
+.Sh HISTORY
+.Nm
+was originally inspired by evilwm, but was rewritten from scratch
+due to limitations in the evilwm codebase.
+The from-scratch rewrite borrowed some code from 9wm, however that code
+has since been removed or rewritten.
+.Pp
+.Nm
+first appeared in
+.Ox 4.2 .
 .Sh AUTHORS
 .An -nosplit
-.Pp
 .Nm
-contains some code from 9wm.
-.Pp
-The
-.Nm
-software has been developed by
+was developed by
 .An Marius Aamodt Eriksen Aq marius@monkey.org
 with contributions from
 .An Andy Adamson Aq dros@monkey.org ,
 .An Niels Provos Aq provos@monkey.org ,
 and
-.An Antti Nyk<EFBFBD>nen Aq aon@iki.fi .
+.An Antti Nyk\(:anen Aq aon@iki.fi .
 Ideas, discussion with many others.
-.\" .Sh HISTORY
-.\".Aq marius@monkey.org .
-.\" .Sh CAVEATS

cwmrc.5

@@ -0,0 +1,504 @@
+.\"	$OpenBSD$
+.\"
+.\" Copyright (c) 2004,2005 Marius Aamodt Eriksen <marius@monkey.org>
+.\"
+.\" Permission to use, copy, modify, and distribute this software for any
+.\" purpose with or without fee is hereby granted, provided that the above
+.\" copyright notice and this permission notice appear in all copies.
+.\"
+.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+.\"
+.Dd $Mdocdate$
+.Dt CWMRC 5
+.Os
+.Sh NAME
+.Nm cwmrc
+.Nd calm window manager configuration file
+.Sh DESCRIPTION
+This manual page describes the
+.Xr cwm 1
+configuration file.
+.Pp
+The current line can be extended over multiple lines using a backslash
+.Pq Sq \e .
+Comments can be put anywhere in the file using a hash mark
+.Pq Sq # ,
+and extend to the end of the current line.
+Care should be taken when commenting out multi-line text:
+the comment is effective until the end of the entire block.
+.Pp
+Arguments containing whitespace should be surrounded by double quotes
+.Pq \&" .
+.Pp
+The following options are accepted:
+.Bl -tag -width Ds
+.It Ic autogroup Ar group Oo Ar windowname , Oc Ns Ar windowclass
+Automatically add new windows to
+.Ar group
+if their class property matches
+.Ar windowclass ,
+or if their name and class properties match
+.Ar windowname
+and
+.Ar windowclass ,
+respectively.
+The more specific last match wins.
+.Ar group
+is a number between 0 and 9.
+If
+.Ar group
+is 0, matching windows will not be added to any group; this may be
+used to override
+.Dq sticky group mode .
+.Pp
+The name and class values, respectively, for existing windows
+are both set in the WM_CLASS property and may be obtained using
+.Xr xprop 1 .
+.It Ic bind-key Ar key function
+Bind or rebind key
+.Ar key
+to
+.Ar function .
+The modifier keys come first, followed by a
+.Sq - ,
+then a keysym name, taken from
+.Pa /usr/X11R6/include/X11/keysymdef.h .
+.Pp
+The following modifiers are recognised:
+.Pp
+.Bl -tag -width Ds -offset indent -compact
+.It Ic C
+Control key.
+.It Ic M
+Meta key.
+.It Ic S
+Shift key.
+.It Ic 4
+Mod4 (windows) key.
+.It Ic 5
+Mod5 (AltGr) key.
+.El
+.Pp
+The
+.Ar function
+may either be one from the
+.Sx BIND FUNCTION LIST
+(see below) or the command line that is to be executed.
+.It Ic bind-mouse Ar button function
+Bind or rebind button
+.Ar button
+to
+.Ar function .
+The modifier keys come first, followed by a
+.Sq - ,
+then the button number.
+.Pp
+The same modifiers are recognised as for
+.Ar key
+in
+.Nm bind-key .
+.Pp
+The following buttons are recognised:
+.Pp
+.Bl -tag -width Ds -offset indent -compact
+.It Ic 1
+Left mouse button.
+.It Ic 2
+Middle mouse button.
+.It Ic 3
+Right mouse button.
+.It Ic 4
+Scroll up mouse button.
+.It Ic 5
+Scroll down mouse button.
+.El
+.Pp
+The
+.Ar function
+may be taken from the
+.Sx BIND FUNCTION LIST
+(see below) or the command line that is to be executed.
+.It Ic borderwidth Ar pixels
+Set the window border width to
+.Ar pixels .
+.It Ic color activeborder Ar color
+Set the color of the active border.
+.It Ic color font Ar color
+Set menu font color.
+.It Ic color selfont Ar color
+Set font color for selected menu item.
+.It Ic color groupborder Ar color
+Set the color of the border while grouping a window.
+.It Ic color inactiveborder Ar color
+Set the color of the inactive border.
+.It Ic color menubg Ar color
+Set menu background color.
+.It Ic color menufg Ar color
+Set menu foreground color.
+.It Ic color urgencyborder Ar color
+Set the color of the border of a window indicating urgency.
+.It Ic color ungroupborder Ar color
+Set the color of the border while ungrouping a window.
+.It Ic command Ar name path
+Every
+.Ar name
+entry is shown in the application menu.
+When selected, the defined
+.Ar path
+is executed with
+.Xr execvp 3 .
+.Pp
+The
+.Ar name
+entries
+.Nm term
+and
+.Nm lock
+have a special meaning.
+They point to the terminal and screen locking programs specified by
+key bindings.
+The defaults are
+.Xr xterm 1
+and
+.Xr xlock 1 ,
+respectively.
+.It Ic fontname Ar font
+Change the default
+.Ar font
+for
+.Xr Xft 3 .
+.It Ic gap Ar top bottom left right
+Define a
+.Dq gap
+in pixels at the edge of the screen, so that when a
+window is maximized it will not overlap this area.
+This
+.Dq gap
+can be used for applications such as
+.Xr xclock 1 ,
+where the user may wish to remain visible.
+.It Ic htile Ar percent
+Set the percentage of screen the master window should occupy
+after calling
+.Ic window-htile .
+If set to 0, the horizontal size of the master window will
+remain unchanged.
+The default is 50.
+.It Ic ignore Ar windowname
+Ignore, and do not warp to, windows with the name
+.Ar windowname
+when drawing borders and cycling through windows.
+.It Ic moveamount Ar pixels
+Set a default size for the keyboard movement bindings,
+in pixels.
+The default is 1.
+.It Ic snapdist Ar pixels
+Minimum distance to snap-to adjacent edge, in pixels.
+The default is 0.
+.It Ic sticky Ic yes Ns \&| Ns Ic no
+Toggle sticky group mode.
+The default behavior for new windows is to not assign any group.
+By enabling sticky group mode,
+.Xr cwm 1
+will assign new windows to the currently selected group.
+.It Ic unbind-key Ar key
+Unbind function bound to
+.Ar key .
+A special
+.Ar key
+keyword
+.Dq all
+can be used to unbind all keys.
+.It Ic unbind-mouse Ar button
+Unbind function bound to
+.Ar button .
+A special
+.Ar button
+keyword
+.Dq all
+can be used to unbind all buttons.
+.It Ic vtile Ar percent
+Set the percentage of screen the master window should occupy
+after calling
+.Ic window-vtile .
+If set to 0, the vertical size of the master window will
+remain unchanged.
+The default is 50.
+.It Ic wm Ar name path
+Every
+.Ar name
+entry is shown in the wm menu.
+When selected, the window manager is replaced by
+.Ar path .
+.El
+.Sh BIND FUNCTION LIST
+.Bl -tag -width 23n -compact
+.It restart
+Restart the running
+.Xr cwm 1 .
+.It quit
+Quit
+.Xr cwm 1 .
+.It terminal
+Spawn a new terminal.
+.It lock
+Lock the screen.
+.It menu-window
+Launch window search menu.
+.It menu-window-hidden
+Launch hidden window search menu.
+.It menu-cmd
+Launch application search menu.
+.It menu-group
+Launch group search menu.
+.It menu-exec
+Launch
+.Dq exec program
+menu.
+.It menu-exec-wm
+Launch
+.Dq exec WindowManager
+menu.
+.It menu-ssh
+Launch
+.Dq ssh
+menu.
+.It group-toggle-[n]
+Toggle visibility of group n, where n is 1-9.
+.It group-only-[n]
+Show only group n, where n is 1-9, hiding other groups.
+.It group-last
+Show only the previously active group.
+.It group-close-[n]
+Close all windows in group n, where n is 1-9.
+.It group-toggle-all
+Toggle visibility of all groups.
+.It window-group
+Toggle group membership of current window.
+.It window-movetogroup-[n]
+Hide current window from display and move to group n, where n is 1-9.
+.It group-cycle
+Forward cycle through groups.
+.It group-rcycle
+Reverse cycle through groups.
+.It window-cycle
+Forward cycle through windows.
+.It window-rcycle
+Reverse cycle through windows.
+.It window-cycle-ingroup
+Forward cycle through windows in current group.
+.It window-rcycle-ingroup
+Reverse cycle through windows in current group.
+.It window-close
+Close current window.
+.It window-hide
+Hide current window.
+.It window-lower
+Lower current window.
+.It window-raise
+Raise current window.
+.It window-menu-label
+Label current window.
+.It window-freeze
+Freeze current window geometry.
+.It window-stick
+Stick current window to all groups (same as assigning to nogroup).
+.It window-fullscreen
+Full-screen current window (gap + border removed).
+.It window-maximize
+Maximize current window (gap + border honored).
+.It window-vmaximize
+Vertically maximize current window (gap + border honored).
+.It window-hmaximize
+Horizontally maximize current window (gap + border honored).
+.It window-htile
+Current window is placed at the top of the screen, maximized
+horizontally and resized to
+.Ar htile
+(default half) of the vertical screen space.
+Other windows in its group share remaining screen space.
+.It window-vtile
+Current window is placed on the left of the screen, maximized vertically
+and resized to
+.Ar vtile
+(default half) of the horizontal screen space.
+Other windows in its group share remaining screen space.
+.It window-move
+Move current window.
+.It window-resize
+Resize current window.
+.It window-move-up
+Move window
+.Ar moveamount
+pixels up.
+.It window-move-down
+Move window
+.Ar moveamount
+pixels down.
+.It window-move-right
+Move window
+.Ar moveamount
+pixels right.
+.It window-move-left
+Move window
+.Ar moveamount
+pixels left.
+.It window-move-up-big
+Move window 10 times
+.Ar moveamount
+pixels up.
+.It window-move-down-big
+Move window 10 times
+.Ar moveamount
+pixels down.
+.It window-move-right-big
+Move window 10 times
+.Ar moveamount
+pixels right.
+.It window-move-left-big
+Move window 10 times
+.Ar moveamount
+pixels left.
+.It window-resize-up
+Resize window
+.Ar moveamount
+pixels up.
+.It window-resize-down
+Resize window
+.Ar moveamount
+pixels down.
+.It window-resize-right
+Resize window
+.Ar moveamount
+pixels right.
+.It window-resize-left
+Resize window
+.Ar moveamount
+pixels left.
+.It window-resize-up-big
+Resize window 10 times
+.Ar moveamount
+pixels up.
+.It window-resize-down-big
+Resize window 10 times
+.Ar moveamount
+pixels down.
+.It window-resize-right-big
+Resize window 10 times
+.Ar moveamount
+pixels right.
+.It window-resize-left-big
+Resize window 10 times
+.Ar moveamount
+pixels left.
+.It window-snap-up
+Snap window to top edge.
+.It window-snap-down
+Snap window to bottom edge.
+.It window-snap-right
+Snap window to right edge.
+.It window-snap-left
+Snap window to left edge.
+.It window-snap-up-right
+Snap window to top-right corner.
+.It window-snap-up-left
+Snap window to top-left corner.
+.It window-snap-down-right
+Snap window to bottom-right corner.
+.It window-snap-down-left
+Snap window to bottom-left corner.
+.It pointer-move-up
+Move pointer
+.Ar moveamount
+pixels up.
+.It pointer-move-down
+Move pointer
+.Ar moveamount
+pixels down.
+.It pointer-move-right
+Move pointer
+.Ar moveamount
+pixels right.
+.It pointer-move-left
+Move pointer
+.Ar moveamount
+pixels left.
+.It pointer-move-up-big
+Move pointer 10 times
+.Ar moveamount
+pixels up.
+.It pointer-move-down-big
+Move pointer 10 times
+.Ar moveamount
+pixels down.
+.It pointer-move-right-big
+Move pointer 10 times
+.Ar moveamount
+pixels right.
+.It pointer-move-left-big
+Move pointer 10 times
+.Ar moveamount
+pixels left.
+.El
+.Sh FILES
+.Bl -tag -width "~/.cwmrcXXX" -compact
+.It Pa ~/.cwmrc
+Default
+.Xr cwm 1
+configuration file.
+.El
+.Sh EXAMPLES
+.Bd -literal
+# Set default Xft(3) font
+fontname "sans-serif:pixelsize=14:bold"
+
+# Turn on sticky-group mode
+sticky yes
+
+# Any entry here is shown in the application menu
+command firefox		firefox
+command xmms		xmms
+command top		"xterm -e top"
+
+# Autogroup definitions
+autogroup 3 "aterm,XTerm"
+autogroup 3 "xterm,XTerm"
+
+# Ignore programs by that name by not drawing borders around them.
+ignore XMMS
+ignore xwi
+ignore xapm
+ignore xclock
+
+# Key bindings
+bind-key CM-r		window-menu-label
+bind-key CS-Return	"xterm -e top"
+bind-key C4-equal	window-vmaximize
+bind-key C4S-equal	window-hmaximize
+bind-key M-1		group-only-1
+bind-key M-2		group-only-2
+bind-key M-3		group-only-3
+bind-key MS-1		window-movetogroup-1
+bind-key MS-2		window-movetogroup-2
+bind-key MS-3		window-movetogroup-3
+unbind-key 4-o
+unbind-key CM-equal
+unbind-key CMS-equal
+
+# Mouse bindings
+bind-mouse M-2		window-lower
+bind-mouse M-3		window-resize
+.Ed
+.Sh SEE ALSO
+.Xr cwm 1
+.Sh HISTORY
+The
+.Nm
+file format first appeared in
+.Ox 4.4 .

draw.c

@@ -1,21 +0,0 @@
-/*
- * calmwm - the calm window manager
- *
- * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
- *
- * $Id$
- */
-
-#include "headers.h"
-#include "calmwm.h"
-
-void
-draw_outline(struct client_ctx *cc)
-{
-	struct screen_ctx *sc = CCTOSC(cc);
-
-        XDrawRectangle(X_Dpy, sc->rootwin, sc->invgc,
-	    cc->geom.x - cc->bwidth, cc->geom.y - cc->bwidth,
-	    cc->geom.width + cc->bwidth, cc->geom.height + cc->bwidth);
-}

font.c

@@ -1,159 +0,0 @@
-/*
- * font.c - cwm font abstraction
- *
- * Copyright (c) 2005 Marius Eriksen <marius@monkey.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#include "hash.h"
-#include "headers.h"
-#include "calmwm.h"
-
-static XftFont *_make_font(struct screen_ctx *sc, struct fontdesc *fdp);
-
-HASH_GENERATE(fonthash, fontdesc, node, fontdesc_cmp);
-
-int
-fontdesc_cmp(struct fontdesc *a, struct fontdesc *b)
-{
-	return strcmp(a->name, b->name);
-}
-
-/*
- * Fowler/Noll/Vo hash
- *    http://www.isthe.com/chongo/tech/comp/fnv/
- */
-
-#define FNV_P_32 ((unsigned int)0x01000193) /* 16777619 */
-#define FNV_1_32 ((unsigned int)0x811c9dc5) /* 2166136261 */
-
-unsigned int
-fontdesc_hash(struct fontdesc *fdp)
-{
-        const unsigned char *p, *end, *start;
-        unsigned int hash = FNV_1_32;
-
-	start = fdp->name;
-	end = (const unsigned char *)fdp->name + strlen(fdp->name);
-
-        for (p = start; p < end; p++) {
-                hash *= FNV_P_32;
-                hash ^= (unsigned int)*p;
-        }
-
-        return (hash);
-}
-
-void
-font_init(struct screen_ctx *sc)
-{
-	XColor xcolor, tmp;
-
-	HASH_INIT(&sc->fonthash, fontdesc_hash);
-	sc->xftdraw = XftDrawCreate(X_Dpy, sc->rootwin,
-	    DefaultVisual(X_Dpy, sc->which), DefaultColormap(X_Dpy, sc->which));
-	if (sc->xftdraw == NULL)
-		errx(1, "XftDrawCreate");
-
-	if (!XAllocNamedColor(X_Dpy, DefaultColormap(X_Dpy, sc->which),
-		"black", &xcolor, &tmp))
-		errx(1, "XAllocNamedColor");
-
-	sc->xftcolor.color.red = xcolor.red;
-	sc->xftcolor.color.green = xcolor.green;
-	sc->xftcolor.color.blue = xcolor.blue;
-	sc->xftcolor.color.alpha = 0x00ff00;
-	sc->xftcolor.pixel = xcolor.pixel;
-}
-
-struct fontdesc *
-font_getx(struct screen_ctx *sc, const char *name)
-{
-	struct fontdesc *fdp;
-
-	if ((fdp = font_get(sc, name)) == NULL)
-		errx(1, "font_get()");
-
-	return (fdp);
-}
-
-struct fontdesc *
-font_get(struct screen_ctx *sc, const char *name)
-{
-	struct fontdesc fd, *fdp;
-	XftFont *fn;
-
-	fd.name = name;
-
-	if ((fdp = HASH_FIND(fonthash, &sc->fonthash, &fd)) == NULL
-	    && (fn = _make_font(sc, &fd)) != NULL) {
-		fdp = xmalloc(sizeof(*fdp));
-		fdp->name = xstrdup(fd.name);
-		fdp->fn = fn;
-		fdp->sc = sc;
-		HASH_INSERT(fonthash, &sc->fonthash, fdp);
-	}
-
-	return (fdp);
-}
-
-int
-font_width(struct fontdesc *fdp, const char *text, int len)
-{
-    XGlyphInfo extents;
-    XftTextExtents8(X_Dpy, fdp->fn, (const XftChar8*)text, len, &extents);
-
-    return (extents.xOff);
-}
-
-void
-font_draw(struct fontdesc *fdp, const char *text, int len,
-    Drawable d, int x, int y)
-{
-	XftDrawChange(fdp->sc->xftdraw, d);
-	/* Really needs to be UTF8'd. */
-	XftDrawString8(fdp->sc->xftdraw, &fdp->sc->xftcolor, fdp->fn, x, y,
-	    (const FcChar8*)text, len);
-}
-
-int
-font_ascent(struct fontdesc *fdp)
-{
-	return fdp->fn->ascent;
-}
-
-int
-font_descent(struct fontdesc *fdp)
-{
-	return fdp->fn->descent;
-}
-
-static XftFont *
-_make_font(struct screen_ctx *sc, struct fontdesc *fdp)
-{
-	XftFont *fn = NULL;
-	FcPattern *pat, *patx;
-	XftResult res;
-
-	if ((pat = FcNameParse(fdp->name)) == NULL)
-		return (NULL);
-
-	if ((patx = XftFontMatch(X_Dpy, sc->which, pat, &res)) != NULL)
-		fn = XftFontOpenPattern(X_Dpy, patx);
-
-	FcPatternDestroy(pat);
-
-	return (fn);
-}
-

geographic.c

@@ -1,53 +0,0 @@
-/*
- * calmwm - the calm window manager
- *
- * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
- *
- * $Id$
- */
-
-#include "headers.h"
-#include "calmwm.h"
-
-struct client_ctx *
-geographic_west(struct client_ctx *from_cc)
-{
-/* 	Window *wins, w0, w1; */
-/* 	struct screen_ctx *sc = screen_current(); */
-/* 	u_int nwins, i; */
-/* 	struct client_ctx *cc; */
-
-	screen_updatestackingorder();
-
-	return (NULL);
-}
-
-#if 0
-int
-_visible(struct client_ctx *this_cc)
-{
-	int stacking = cc->stackingorder;
-	struct client_ctx *cc;
-
-	if (cc->flags & CLIENT_HIDDEN)
-		return (0);
-
-	TAILQ_FOREACH(cc, &Clientq, entry) {
-		if (cc->flags & CLIENT_HIDDEN)
-			continue;
-
-		if (cc->stackingorder > stacking &&
-		    cc->geom.x <= this_cc->geom.x &&
-		    cc->geom.y <= this_cc->geom.y &&
-		    cc->geom.width > (this_cc->geom.width +
-			(this_cc->geom.x - cc->geom.x) &&
-
-
-		    cc->geom.height > (this_cc->geom.height - cc->geom.height))
-			return (0);
-	}
-
-	return (1);
-}
-#endif

grab.c

@@ -1,560 +0,0 @@
-/*
- * calmwm - the calm window manager
- *
- * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
- *
- * $Id$
- */
-
-#include "headers.h"
-#include "calmwm.h"
-
-int _sweepcalc(struct client_ctx *, int, int, int, int);
-int  _nobuttons(XButtonEvent *);
-
-#define ADJUST_HEIGHT(cc, dy)	((cc->geom.height - cc->geom.min_dy)/ dy)
-#define ADJUST_WIDTH(cc, dx)	((cc->geom.width - cc->geom.min_dx)/ dx)
-
-void
-grab_sweep_draw(struct client_ctx *cc, int dx, int dy)
-{
-	struct screen_ctx *sc = CCTOSC(cc);
-	int x0 = cc->geom.x, y0 = cc->geom.y;
-	char asize[10];	/* fits "nnnnxnnnn\0" */
-	int wide, height, wide_size, wide_name;
-	struct fontdesc *font = DefaultFont;
-
-	snprintf(asize, sizeof(asize), "%dx%d",
-	    ADJUST_WIDTH(cc, dx), ADJUST_HEIGHT(cc, dy));
-	wide_size = font_width(font, asize, strlen(asize)) + 4;
-	wide_name = font_width(font, cc->name, strlen(cc->name)) + 4;
-	wide = MAX(wide_size, wide_name);
-	height = font_ascent(font) + font_descent(font) + 1;
-
-	XMoveResizeWindow(X_Dpy, sc->menuwin, x0, y0, wide, height * 2);
-	XMapWindow(X_Dpy, sc->menuwin);
-	XReparentWindow(X_Dpy, sc->menuwin, cc->win, 0, 0);
-	XClearWindow(X_Dpy, sc->menuwin);
-	font_draw(font, cc->name, strlen(cc->name), sc->menuwin,
-	    2, font_ascent(font) + 1);
-	font_draw(font, asize, strlen(asize), sc->menuwin,
-	    wide/2 - wide_size/2, height + font_ascent(font) + 1);
-}
-
-int
-grab_sweep(struct client_ctx *cc)
-{
-	XEvent ev;
-	struct screen_ctx *sc = CCTOSC(cc);
-	int x0 = cc->geom.x, y0 = cc->geom.y;
-	int dx, dy;
-
-	dx = MAX(1, cc->size->width_inc);
-	dy = MAX(1, cc->size->height_inc);
-
-	client_raise(cc);
-	client_ptrsave(cc);
-
-	if (xu_ptr_grab(sc->rootwin, MouseMask, Cursor_resize) < 0)
-		return (-1);
-
-	xu_ptr_setpos(cc->win, cc->geom.width, cc->geom.height);
-	grab_sweep_draw(cc, dx, dy);
-
-	for (;;) {
-		/* Look for changes in ptr position. */
-		XMaskEvent(X_Dpy, MouseMask|ExposureMask, &ev);
-
-		switch (ev.type) {
-		case Expose:
-			client_draw_border(cc);
-			break;
-		case MotionNotify:
-			if (_sweepcalc(cc, x0, y0, ev.xmotion.x, ev.xmotion.y))
- 				/* Recompute window output */
-				grab_sweep_draw(cc, dx, dy);
-
-			XMoveResizeWindow(X_Dpy, cc->pwin,
-			    cc->geom.x - cc->bwidth,
-			    cc->geom.y - cc->bwidth,
-			    cc->geom.width + cc->bwidth*2,
-			    cc->geom.height + cc->bwidth*2);
-			XMoveResizeWindow(X_Dpy, cc->win,
-			    cc->bwidth, cc->bwidth,
-			    cc->geom.width, cc->geom.height);
-
-			break;
-		case ButtonRelease:
-			XUnmapWindow(X_Dpy, sc->menuwin);
-			XReparentWindow(X_Dpy, sc->menuwin, sc->rootwin, 0, 0);
-			xu_ptr_ungrab();
-			client_ptrwarp(cc);
-			return (0);
-		}
-	}
-	/* NOTREACHED */
-}
-
-int
-grab_drag(struct client_ctx *cc)
-{
-	int x0 = cc->geom.x, y0 = cc->geom.y, xm, ym;
-	struct screen_ctx *sc = CCTOSC(cc);
-	XEvent ev;
-
-	client_raise(cc);
-
-	if (xu_ptr_grab(sc->rootwin, MouseMask, Cursor_move) < 0)
-		return (-1);
-
-	xu_ptr_getpos(sc->rootwin, &xm, &ym);
-
-	for (;;) {
-		XMaskEvent(X_Dpy, MouseMask|ExposureMask, &ev);
-
-		switch (ev.type) {
-		case Expose:
-			client_draw_border(cc);
-			break;
-		case MotionNotify:
-			cc->geom.x = x0 + (ev.xmotion.x - xm);
-			cc->geom.y = y0 + (ev.xmotion.y - ym);
-
-			XMoveWindow(X_Dpy, cc->pwin,
-			    cc->geom.x - cc->bwidth, cc->geom.y - cc->bwidth);
-
-			break;
-		case ButtonRelease:
-			xu_ptr_ungrab();
-			return (0);
-		}
-	}
-	/* NOTREACHED */
-}
-
-/*
- * Adapted from 9wm.
- */
-
-/* XXX - this REALLY needs to be cleaned up. */
-
-#define MenuMask       (ButtonMask|ButtonMotionMask|ExposureMask)
-#define MenuGrabMask   (ButtonMask|ButtonMotionMask|StructureNotifyMask)
-#define AllButtonMask   (Button1Mask|Button2Mask|Button3Mask|Button4Mask|Button5Mask)
-
-#ifdef notyet
-struct client_ctx *
-grab_menu_getcc(struct menu_q *menuq, int off)
-{
-	int where = 0;
-	struct menu *mi;
-
-	TAILQ_FOREACH(mi, menuq, entry)
-	    if (off == where++)
-		    return mi->ctx;
-	return (NULL);
-}
-#endif
-
-void *
-grab_menu(XButtonEvent *e, struct menu_q *menuq)
-{
-	struct screen_ctx *sc;
-	struct menu *mi;
-	XEvent ev;
-	int i, n, cur = 0, old, wide, high, status, drawn, warp;
-	int x, y, dx, dy, xmax, ymax;
-	int tx, ty;
-	struct fontdesc *font = DefaultFont;
-
-	if ((sc = screen_fromroot(e->root)) == NULL || e->window == sc->menuwin)
-		return (NULL);
-
-	dx = 0;
-	i = 0;
-	TAILQ_FOREACH(mi, menuq, entry) {
-		wide = font_width(font, mi->text, strlen(mi->text)) + 4;
-		if (wide > dx)
-			dx = wide;
-		if (mi->lasthit)
-			cur = i;
-		i++;
-	}
-
-	n = i;
-
-	wide = dx;
-	high = font_ascent(font) + font_descent(font) + 1;
-	dy = n*high;
-	x = e->x - wide/2;
-	y = e->y - cur*high - high/2;
-	warp = 0;
-	/* XXX - cache these in sc. */
-	xmax = DisplayWidth(X_Dpy, sc->which);
-	ymax = DisplayHeight(X_Dpy, sc->which);
-	if (x < 0) {
-		e->x -= x;
-		x = 0;
-		warp++;
-	}
-	if (x+wide >= xmax) {
-		e->x -= x+wide-xmax;
-		x = xmax-wide;
-		warp++;
-	}
-	if (y < 0) {
-		e->y -= y;
-		y = 0;
-		warp++;
-	}
-	if (y+dy >= ymax) {
-		e->y -= y+dy-ymax;
-		y = ymax-dy;
-		warp++;
-	}
-	if (warp)
-		xu_ptr_setpos(e->root, e->x, e->y);
-
-	XMoveResizeWindow(X_Dpy, sc->menuwin, x, y, dx, dy);
-	XSelectInput(X_Dpy, sc->menuwin, MenuMask);
-	XMapRaised(X_Dpy, sc->menuwin);
-	status = xu_ptr_grab(sc->menuwin, MenuGrabMask, Cursor_select);
-	if (status < 0) {
-		XUnmapWindow(X_Dpy, sc->menuwin);
-		return (NULL);
-	}
-	drawn = 0;
-
-#ifdef notyet
-	if (e->button == Button1) {
-		struct client_ctx *cc;
-		cc = grab_menu_getcc(menuq, cur);
-		if (cc != NULL) {
-			client_unhide(cc);
-			XRaiseWindow(X_Dpy, sc->menuwin);
-		}
-	}
-#endif
-
-	for (;;) {
-		XMaskEvent(X_Dpy, MenuMask, &ev);
-		switch (ev.type) {
-		default:
-			warnx("menuhit: unknown ev.type %d\n", ev.type);
-			break;
-		case ButtonPress:
-			break;
-		case ButtonRelease:
-			if (ev.xbutton.button != e->button)
-				break;
-			x = ev.xbutton.x;
-			y = ev.xbutton.y;
-			i = y/high;
-			if (cur >= 0 && y >= cur*high-3 && y < (cur+1)*high+3)
-				i = cur;
-			if (x < 0 || x > wide || y < -3)
-				i = -1;
-			else if (i < 0 || i >= n)
-				i = -1;
-/* 			else */
-/* 				m->lasthit = i; */
-			if (!_nobuttons(&ev.xbutton))
-				i = -1;
-
-			/* XXX */
-			/* 			ungrab(&ev.xbutton); */
-			xu_ptr_ungrab();
-			XUnmapWindow(X_Dpy, sc->menuwin);
-			n = 0;
-			TAILQ_FOREACH(mi, menuq, entry)
-				if (i == n++)
-					break;
-
-			return (mi);
-		case MotionNotify:
-			if (!drawn)
-				break;
-			x = ev.xbutton.x;
-			y = ev.xbutton.y;
-			old = cur;
-			cur = y/high;
-			if (old >= 0 && y >= old*high-3 && y < (old+1)*high+3)
-				cur = old;
-			if (x < 0 || x > wide || y < -3)
-				cur = -1;
-			else if (cur < 0 || cur >= n)
-				cur = -1;
-			if (cur == old)
-				break;
-			if (old >= 0 && old < n) {
-#ifdef notyet
-				if (e->button == Button1) {
-					struct client_ctx *cc;
-					cc = grab_menu_getcc(menuq, old);
-					if (cc != NULL)
-						client_hide(cc);
-				}
-#endif
-				XFillRectangle(X_Dpy, sc->menuwin,
-				    sc->hlgc, 0, old*high, wide, high);
-			}
-			if (cur >= 0 && cur < n) {
-#ifdef notyet
-				if (e->button == Button1) {
-					struct client_ctx *cc;
-					cc = grab_menu_getcc(menuq, cur);
-					if (cc != NULL) {
-						client_unhide(cc);
-						XRaiseWindow(X_Dpy,
-						    sc->menuwin);
-					}
-				}
-#endif
-				xu_ptr_regrab(MenuGrabMask, Cursor_select);
-				XFillRectangle(X_Dpy, sc->menuwin,
-				    sc->hlgc, 0, cur*high, wide, high);
-			} else
-				xu_ptr_regrab(MenuGrabMask, Cursor_default);
-			break;
-		case Expose:
-			XClearWindow(X_Dpy, sc->menuwin);
-			i = 0;
-			TAILQ_FOREACH(mi, menuq, entry) {
-				tx = (wide - font_width(font, mi->text,
-					strlen(mi->text)))/2;
-				ty = i*high + font_ascent(font) + 1;
-				font_draw(font, mi->text, strlen(mi->text),
-				    sc->menuwin, tx, ty);
-				i++;
-			}
-			if (cur >= 0 && cur < n)
-				XFillRectangle(X_Dpy, sc->menuwin,
-				    sc->hlgc, 0, cur*high, wide, high);
-			drawn = 1;
-		}
-	}
-}
-
-void
-grab_menuinit(struct screen_ctx *sc)
-{
-	sc->menuwin = XCreateSimpleWindow(X_Dpy, sc->rootwin, 0, 0,
-	    1, 1, 1, sc->blackpixl, sc->whitepixl);
-}
-
-#define LABEL_MAXLEN 256
-#define LabelMask (KeyPressMask|ExposureMask)
-
-void
-grab_label(struct client_ctx *cc)
-{
-	struct screen_ctx *sc = screen_current();
-	int x, y, dx, dy, fontheight, focusrevert;
-	XEvent e;
-	char labelstr[LABEL_MAXLEN];
-	char dispstr[LABEL_MAXLEN + sizeof("label>") - 1];
-	Window focuswin;
-	char chr;
-	enum ctltype ctl;
-	size_t len;
-	struct fontdesc *font = DefaultFont;
-
-	if (cc->label != NULL)
-		strlcpy(labelstr, cc->label, sizeof(labelstr));
-	else
-		labelstr[0] = '\0';
-
-	xu_ptr_getpos(sc->rootwin, &x, &y);
-
-	dy = fontheight = font_ascent(font) + font_descent(font) + 1;
-	dx = font_width(font, "label>", 6);
-
-	XMoveResizeWindow(X_Dpy, sc->searchwin, x, y, dx, dy);
-	XSelectInput(X_Dpy, sc->searchwin, LabelMask);
-	XMapRaised(X_Dpy, sc->searchwin);
-
-	XGetInputFocus(X_Dpy, &focuswin, &focusrevert);
-	XSetInputFocus(X_Dpy, sc->searchwin,
-	    RevertToPointerRoot, CurrentTime);
-
-	for (;;) {
-		XMaskEvent(X_Dpy, LabelMask, &e);
-
-		switch (e.type) {
-		case KeyPress:
-			if (input_keycodetrans(e.xkey.keycode, e.xkey.state,
-				&ctl, &chr, 0) < 0)
-				continue;
-
-			switch (ctl) {
-			case CTL_ERASEONE:
-				if ((len = strlen(labelstr)) > 0)
-					labelstr[len - 1] = '\0';
-				break;
-			case CTL_RETURN:
-				/* Done */
-				if (strlen(labelstr) == 0)
-					goto out;
-
-				if (cc->label != NULL)
-					xfree(cc->label);
-
-				cc->label = xstrdup(labelstr);
-
-			case CTL_ABORT:
-				goto out;
-			default:
-				break;
-			}
-
-			if (chr != '\0') {
-				char str[2];
-
-				str[0] = chr;
-				str[1] = '\0';
-				strlcat(labelstr, str, sizeof(labelstr));
-			}
-
-		case Expose:
-			snprintf(dispstr, sizeof(dispstr), "label>%s", labelstr);
-			dx = font_width(font, dispstr, strlen(dispstr));
-			dy = fontheight;
-
-			XClearWindow(X_Dpy, sc->searchwin);
-			XResizeWindow(X_Dpy, sc->searchwin, dx, dy);
-
-			font_draw(font, dispstr, strlen(dispstr),
-			    sc->searchwin, 0, font_ascent(font) + 1);
-			break;
-		}
-	}
-
- out:
-	XSetInputFocus(X_Dpy, focuswin,
-	    focusrevert, CurrentTime);
-	XUnmapWindow(X_Dpy, sc->searchwin);
-}
-
-#define ExecMask (KeyPressMask|ExposureMask)
-
-void
-grab_exec(void)
-{
-	int x, y, dx, dy, fontheight, focusrevert, len;
-	char cmdstr[MAXPATHLEN];
-	char dispstr[MAXPATHLEN + sizeof("exec>") - 1];
-	char chr, str[2];
-	enum ctltype ctl;
-	struct fontdesc *font = DefaultFont;
-	struct screen_ctx *sc = screen_current();
-	XEvent e;
-	Window focuswin;
-
-	cmdstr[0] = '\0';
-
-	xu_ptr_getpos(sc->rootwin, &x, &y);
-
-	dy = fontheight = font_ascent(font) + font_descent(font) + 1;
-	dx = font_width(font, "exec>", 5);
-
-	XMoveResizeWindow(X_Dpy, sc->searchwin, x, y, dx, dy);
-	XSelectInput(X_Dpy, sc->searchwin, ExecMask);
-	XMapRaised(X_Dpy, sc->searchwin);
-
-	XGetInputFocus(X_Dpy, &focuswin, &focusrevert);
-	XSetInputFocus(X_Dpy, sc->searchwin,
-	    RevertToPointerRoot, CurrentTime);
-
-	for (;;) {
-		XMaskEvent(X_Dpy, ExecMask, &e);
-
-		switch (e.type) {
-		case KeyPress:
-			if (input_keycodetrans(e.xkey.keycode, e.xkey.state,
-				&ctl, &chr, 0) < 0)
-				continue;
-
-			switch (ctl) {
-			case CTL_ERASEONE:
-				if ((len = strlen(cmdstr)) > 0)
-					cmdstr[len - 1] = '\0';
-				break;
-			case CTL_RETURN:
-				if (strlen(cmdstr) > 0)
-					u_spawn(cmdstr);
-				goto out;
-				break;
-			case CTL_ABORT:
-				goto out;
-			default:
-				break;
-			}
-
-			if (chr != '\0') {
-				str[0] = chr;
-				str[1] = '\0';
-				strlcat(cmdstr, str, sizeof(cmdstr));
-			}
-		case Expose:
-			snprintf(dispstr, sizeof(dispstr), "exec>%s", cmdstr);
-
-			dx = font_width(font, dispstr, strlen(dispstr));
-			dy = fontheight;
-
-			XClearWindow(X_Dpy, sc->searchwin);
-			XResizeWindow(X_Dpy, sc->searchwin, dx, dy);
-
-			font_draw(font, dispstr, strlen(dispstr),
-			    sc->searchwin, 0, font_ascent(font) + 1);
-			break;
-		}
-	}
- out:
-	XSetInputFocus(X_Dpy, focuswin, focusrevert, CurrentTime);
-	XUnmapWindow(X_Dpy, sc->searchwin);
-}
-
-int
-_sweepcalc(struct client_ctx *cc, int x0, int y0, int motionx, int motiony)
-{
-	int width, height;
-
-	width = cc->geom.width;
-	height = cc->geom.height;
-
-	cc->geom.width = abs(x0 - motionx);
-	cc->geom.height = abs(y0 - motiony);
-
-	if (cc->size->flags & PResizeInc) {
-		cc->geom.width -=
-		    (cc->geom.width - cc->geom.min_dx) % cc->size->width_inc;
-		cc->geom.height -=
-		    (cc->geom.height - cc->geom.min_dy) % cc->size->height_inc;
-	}
-
-	if (cc->size->flags & PMinSize) {
-		cc->geom.width = MAX(cc->geom.width, cc->size->min_width);
-		cc->geom.height = MAX(cc->geom.height, cc->size->min_height);
-	}
-
-	if (cc->size->flags & PMaxSize) {
-		cc->geom.width = MIN(cc->geom.width, cc->size->max_width);
-		cc->geom.height = MIN(cc->geom.height, cc->size->max_height);
-	}
-
-	cc->geom.x = x0 <= motionx ? x0 : x0 - cc->geom.width;
-	cc->geom.y = y0 <= motiony ? y0 : y0 - cc->geom.height;
-
-	return (width != cc->geom.width || height != cc->geom.height);
-}
-
-/* XXX */
-int
-_nobuttons(XButtonEvent *e)	/* Einstuerzende */
-{
-	int state;
-
-	state = (e->state & AllButtonMask);
-	return (e->type == ButtonRelease) && (state & (state - 1)) == 0;
-}

group.c

@@ -3,131 +3,112 @@
  *
  * Copyright (c) 2004 Andy Adamson <dros@monkey.org>
  * Copyright (c) 2004,2005 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-#define CALMWM_NGROUPS 9
+static struct group_ctx	*group_next(struct group_ctx *);
+static struct group_ctx	*group_prev(struct group_ctx *);
+static void		 group_restack(struct group_ctx *);
+static void		 group_set_active(struct group_ctx *);
 
-int                 Groupmode = 0;
-int                 Groupnamemode = 0;
-struct group_ctx   *Group_active = NULL;
-struct group_ctx   *Group_current = NULL;
-struct group_ctx    Groups[CALMWM_NGROUPS];
-char                Group_name[256];
-int                 Groupfocusset = 0;
-Window              Groupfocuswin;
-int                 Groupfocusrevert;
-int                 Grouphideall = 0;
-struct group_ctx_q  Groupq;
-
-#define GroupMask (KeyPressMask|ExposureMask)
-
-static char *shortcut_to_name[] = {
-	"XXX", "one", "two", "three",
-	"four", "five", "six", "seven",
-	"eight", "nine",
-};
-
-static void
-_group_add(struct group_ctx *gc, struct client_ctx *cc)
+void
+group_assign(struct group_ctx *gc, struct client_ctx *cc)
 {
-	if (cc == NULL || gc == NULL)
-	  	errx(1, "_group_add: a ctx is NULL");
+	if ((gc != NULL) && (gc->num == 0))
+		gc = NULL;
 
-	if (cc->group == gc)
-		return;
+	cc->gc = gc;
 
-	if (cc->group != NULL)
-		TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
-
-	TAILQ_INSERT_TAIL(&gc->clients, cc, group_entry);
-	cc->group = gc;
-	cc->groupcommit = 0;
+	xu_ewmh_set_net_wm_desktop(cc);
 }
 
-static void
-_group_remove(struct client_ctx *cc)
+void
+group_hide(struct group_ctx *gc)
 {
-	if (cc == NULL || cc->group == NULL)
-	  	errx(1, "_group_remove: a ctx is NULL");
+	struct screen_ctx	*sc = gc->sc;
+	struct client_ctx	*cc;
 
-	TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
-	cc->group = NULL;
-	cc->groupcommit = 0;
-	cc->highlight = 0;
-	client_draw_border(cc);
-}
+	screen_updatestackingorder(gc->sc);
 
-static void
-_group_commit(struct group_ctx *gc)
-{
-  	struct client_ctx *cc;
-
-	if (gc == NULL)
-		errx(1, "_group_commit: ctx is null");
-
-	TAILQ_FOREACH(cc, &gc->clients, group_entry)
-		cc->groupcommit = 1;
-}
-
-static void
-_group_purge(struct group_ctx *gc)
-{
-	struct client_ctx *cc;
-
-	if (gc == NULL)
-		errx(1, "_group_commit: ctx is null");
-
-	TAILQ_FOREACH(cc, &gc->clients, group_entry)
-		if (cc->groupcommit == 0)
-			_group_remove(cc);
-}
-
-
-static void
-_group_hide(struct group_ctx *gc)
-{
-  	struct client_ctx *cc;
-
-	screen_updatestackingorder();
-
-	gc->nhidden = 0;
-	gc->highstack = 0;
-	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
-		client_hide(cc);
-		gc->nhidden++;
-		if (cc->stackingorder > gc->highstack)
-			gc->highstack = cc->stackingorder;
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		if (!(cc->flags & CLIENT_STICKY) &&
+		    !(cc->flags & CLIENT_HIDDEN))
+			client_hide(cc);
 	}
-	gc->hidden = 1;		/* XXX: equivalent to gc->nhidden > 0 */
+}
+
+void
+group_show(struct group_ctx *gc)
+{
+	struct screen_ctx	*sc = gc->sc;
+	struct client_ctx	*cc;
+
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		if (!(cc->flags & CLIENT_STICKY) &&
+		     (cc->flags & CLIENT_HIDDEN))
+			client_show(cc);
+	}
+	group_restack(gc);
+	group_set_active(gc);
 }
 
 static void
-_group_show(struct group_ctx *gc)
+group_restack(struct group_ctx *gc)
 {
-	struct client_ctx *cc;
-	Window *winlist;
-	u_int i;
-	int lastempty = -1;
+	struct screen_ctx	*sc = gc->sc;
+	struct client_ctx	*cc;
+	Window			*winlist;
+	int			 i, lastempty = -1;
+	int			 nwins = 0, highstack = 0;
 
-	winlist = (Window *) xcalloc(sizeof(*winlist) * (gc->highstack + 1));
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		if (cc->stackingorder > highstack)
+			highstack = cc->stackingorder;
+	}
+	winlist = xreallocarray(NULL, (highstack + 1), sizeof(*winlist));
 
-	/*
-	 * Invert the stacking order as XRestackWindows() expects them
-	 * top-to-bottom.
-	 */
-	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
-		winlist[gc->highstack - cc->stackingorder] = cc->pwin;
-		client_unhide(cc);
+	/* Invert the stacking order for XRestackWindows(). */
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		winlist[highstack - cc->stackingorder] = cc->win;
+		nwins++;
 	}
 
 	/* Un-sparseify */
-	for (i = 0; i <= gc->highstack; i++) {
+	for (i = 0; i <= highstack; i++) {
 		if (!winlist[i] && lastempty == -1)
 			lastempty = i;
 		else if (winlist[i] && lastempty != -1) {
@@ -137,498 +118,261 @@ _group_show(struct group_ctx *gc)
 		}
 	}
 
-	XRestackWindows(X_Dpy, winlist, gc->nhidden);
-	xfree(winlist);
-
-	gc->hidden = 0;
-	Group_active = gc;
-}
-
-
-
-static void
-_group_destroy(struct group_ctx *gc)
-{
-	struct client_ctx *cc;
-
-	if (gc->name != NULL) {
-		xfree(gc->name);
-		gc->name = NULL;
-	}
-
-	while ((cc = TAILQ_FIRST(&gc->clients)) != NULL) {
-		TAILQ_REMOVE(&gc->clients, cc, group_entry);
-		cc->group = NULL;
-		cc->groupcommit = 0;
-		cc->highlight = 0;
-		client_draw_border(cc);
-	}
+	XRestackWindows(X_Dpy, winlist, nwins);
+	free(winlist);
 }
 
 void
-group_init(void)
+group_init(struct screen_ctx *sc, int num, const char *name)
 {
-  	int i;
+	struct group_ctx	*gc;
 
-	TAILQ_INIT(&Groupq);
+	gc = xmalloc(sizeof(*gc));
+	gc->sc = sc;
+	gc->name = xstrdup(name);
+	gc->num = num;
+	TAILQ_INSERT_TAIL(&sc->groupq, gc, entry);
 
-	for (i = 0; i < CALMWM_NGROUPS; i++) {
-		TAILQ_INIT(&Groups[i].clients);
-		Groups[i].hidden = 0;
-		Groups[i].shortcut = i + 1;
-		TAILQ_INSERT_TAIL(&Groupq, &Groups[i], entry);
-	}
-
-	Group_current = Group_active = &Groups[0];
+	if (num == 1)
+		group_set_active(gc);
 }
 
-/* 
- * manipulate the 'current group'
- */
-
-#if 0
-/* set current group to the first empty group
- * returns 0 on success, -1 if there are no empty groups
- */
-int
-group_new(void)
+void
+group_set_active(struct group_ctx *gc)
 {
-  	int i;
+	struct screen_ctx	*sc = gc->sc;
 
-	for (i=0; i < CALMWM_NGROUPS; i++) {
-		if (TAILQ_EMPTY(&Groups[i].clients)) {
-			Group_current = &Groups[i];			
+	sc->group_active = gc;
 
-			return (0);
+	xu_ewmh_net_current_desktop(sc);
+}
+
+void
+group_movetogroup(struct client_ctx *cc, int idx)
+{
+	struct screen_ctx	*sc = cc->sc;
+	struct group_ctx	*gc;
+
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == idx) {
+			if (cc->gc == gc)
+				return;
+			if (gc->num != 0 && group_holds_only_hidden(gc))
+				client_hide(cc);
+			group_assign(gc, cc);
 		}
 	}
-
-	return (-1);
 }
-#endif
 
-/* change the current group */
+void
+group_toggle_membership(struct client_ctx *cc)
+{
+	struct screen_ctx	*sc = cc->sc;
+	struct group_ctx	*gc = sc->group_active;
+
+	if (cc->gc == gc) {
+		group_assign(NULL, cc);
+		cc->flags |= CLIENT_UNGROUP;
+	} else {
+		group_assign(gc, cc);
+		cc->flags |= CLIENT_GROUP;
+	}
+	client_draw_border(cc);
+}
+
 int
-group_select(int idx)
+group_holds_only_sticky(struct group_ctx *gc)
 {
-	struct group_ctx *gc = Group_current;
-	struct client_ctx *cc;
+	struct screen_ctx	*sc = gc->sc;
+	struct client_ctx	*cc;
 
-	if (idx < 0 || idx >= CALMWM_NGROUPS)
-		return (-1);
-
-	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
-		cc->highlight = 0;
-		client_draw_border(cc);
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		if (!(cc->flags & CLIENT_STICKY))
+			return 0;
 	}
-
-	_group_commit(gc);
-	Group_current = &Groups[idx];
-
-	group_display_draw(screen_current());
-	return (0);
+	return 1;
 }
 
-/* enter group mode */
-void
-group_enter(void)
+int
+group_holds_only_hidden(struct group_ctx *gc)
 {
-  	if (Groupmode != 0)
-		errx(1, "group_enter called twice");
+	struct screen_ctx	*sc = gc->sc;
+	struct client_ctx	*cc;
 
-	if (Group_current == NULL)
-		Group_current = &Groups[0];
-
-	/* setup input buffer */
-	Group_name[0] = '\0';
-
-  	Groupmode = 1;
-
-	group_display_init(screen_current());
-	group_display_draw(screen_current());
-}
-
-/* exit group mode */
-void
-group_exit(int commit)
-{
-	struct group_ctx *gc = Group_current;
-	struct client_ctx *cc;
-
-  	if (Groupmode != 1)
-		errx(1, "group_exit called twice");
-
-	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
-		cc->highlight = 0;
-		client_draw_border(cc);
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		if (!(cc->flags & (CLIENT_HIDDEN | CLIENT_STICKY)))
+			return 0;
 	}
+	return 1;
+}
 
-	if (commit) {
-		_group_commit(gc);
-	} else {
-	  	/* abort */
-	  	_group_purge(gc);
-		if (!TAILQ_EMPTY(&gc->clients))
-	  		_group_destroy(gc);
+void
+group_only(struct screen_ctx *sc, int idx)
+{
+	struct group_ctx	*gc;
+
+	if (sc->group_last != sc->group_active)
+		sc->group_last = sc->group_active;
+
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == idx)
+			group_show(gc);
+		else
+			group_hide(gc);
 	}
+}
 
-	XUnmapWindow(X_Dpy, screen_current()->groupwin);
+void
+group_toggle(struct screen_ctx *sc, int idx)
+{
+	struct group_ctx	*gc;
 
-	if (Groupnamemode) {
-		XSetInputFocus(X_Dpy, Groupfocuswin, Groupfocusrevert,
-		    CurrentTime);
-		Groupfocusset = 0;
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == idx) {
+			if (group_holds_only_hidden(gc))
+				group_show(gc);
+			else
+				group_hide(gc);
+		}
 	}
-
-  	Groupmode = Groupnamemode = 0;
 }
 
 void
-group_click(struct client_ctx *cc)
+group_toggle_all(struct screen_ctx *sc)
 {
-	struct group_ctx *gc = Group_current;
+	struct group_ctx	*gc;
 
-	if (gc == cc->group)
-		_group_remove(cc);
-	else 
-		_group_add(gc, cc);
-	group_display_draw(screen_current());
-}
-
-
-/* Used to add a newly mapped window to the active group */
-
-void
-group_sticky(struct client_ctx *cc)
-{
-	_group_add(Group_active, cc);
-}
-
-void
-group_sticky_toggle_enter(struct client_ctx *cc)
-{
-	struct group_ctx *gc = Group_active;
-
-	if (gc == cc->group) {
-		_group_remove(cc);
-		cc->highlight = CLIENT_HIGHLIGHT_RED;
-	} else {
-		_group_add(gc, cc);
-		cc->highlight = CLIENT_HIGHLIGHT_BLUE;
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (sc->hideall)
+			group_show(gc);
+		else
+			group_hide(gc);
 	}
-
-	client_draw_border(cc);
+	sc->hideall = !sc->hideall;
 }
 
 void
-group_sticky_toggle_exit(struct client_ctx *cc)
+group_close(struct screen_ctx *sc, int idx)
 {
-	cc->highlight = 0;
-	client_draw_border(cc);
-}
+	struct group_ctx	*gc;
+	struct client_ctx	*cc;
 
-/*
- * selection list display 
- */
-
-void
-group_display_init(struct screen_ctx *sc)
-{
-	sc->groupwin = XCreateSimpleWindow(X_Dpy, sc->rootwin, 0, 0,
-	    1, 1, 1, sc->blackpixl, sc->whitepixl);
-}
-
-void
-group_display_draw(struct screen_ctx *sc)
-{
-	struct group_ctx *gc = Group_current;
-	int x, y, dx, dy, fontheight, titlelen;
-	struct client_ctx *cc;
-	char titlebuf[1024];
-	struct fontdesc *font = DefaultFont;
-
-	snprintf(titlebuf, sizeof(titlebuf), "Editing group %d", gc->shortcut);
-
-	x = y = 0;
-
-	fontheight = font_ascent(font) + font_descent(font) + 1;
-	dx = titlelen = font_width(font, titlebuf, strlen(titlebuf));
-	dy = fontheight;
-
-	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
-		cc->highlight = CLIENT_HIGHLIGHT_BLUE;
-		client_draw_border(cc);
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == idx) {
+			TAILQ_FOREACH(cc, &sc->clientq, entry) {
+				if (cc->gc != gc)
+					continue;
+				client_close(cc);
+			}
+		}
 	}
-
-	XMoveResizeWindow(X_Dpy, sc->groupwin, x, y, dx, dy);
-
-	/* XXX */
-	XSelectInput(X_Dpy, sc->groupwin, GroupMask);
-
-	XMapRaised(X_Dpy, sc->groupwin);
-	XClearWindow(X_Dpy, sc->groupwin);
-	font_draw(font, titlebuf, strlen(titlebuf), sc->groupwin,
-	    0, font_ascent(font) + 1);
-}
-
-void 
-group_display_keypress(KeyCode k)
-{
-	struct group_ctx * gc = Group_current;
-	char chr;
-	enum ctltype ctl;
-	int len;
-
-	if (!Groupnamemode)
-		return;
-
-	if (input_keycodetrans(k, 0, &ctl, &chr, 1) < 0)
-		goto out;
-
-	switch (ctl) {
-	case CTL_ERASEONE:
-	  	if ((len = strlen(Group_name)) > 0)
-			Group_name[len - 1] = '\0';
-		break;
-	case CTL_RETURN:
-		if (gc->name != NULL)
-			xfree(gc->name);
-
-		gc->name = xstrdup(Group_name);
-
-		group_exit(1);
-		return;
-	default:
-		break;
-	}
-
-	if (chr != '\0')
-		snprintf(Group_name, sizeof(Group_name), "%s%c", 
-		    Group_name, chr);
-
-out:
-	group_display_draw(screen_current());
-}
-
-/* if group_hidetoggle would produce no effect, toggle the group's hidden state
- */
-void
-_group_fix_hidden_state(struct group_ctx *gc)
-{
-	struct client_ctx *cc;	
-	int same = 0;
-
-	TAILQ_FOREACH(cc, &gc->clients, group_entry) {
-		if (gc->hidden == ((cc->flags & CLIENT_HIDDEN) ? 1 : 0))
-			same++;
-	}
-
-	if (same == 0)
-		gc->hidden = !gc->hidden;
 }
 
 void
-group_hidetoggle(int idx)
+group_cycle(struct screen_ctx *sc, int flags)
 {
-	struct group_ctx *gc;
-#ifdef notyet
-	char buf[128];
-#endif
+	struct group_ctx	*newgc, *oldgc, *showgroup = NULL;
 
-	if (idx < 0 || idx >= CALMWM_NGROUPS)
-		err(1, "group_hidetoggle: index out of range (%d)", idx);
+	oldgc = sc->group_active;
 
-	gc = &Groups[idx];
-
-	_group_fix_hidden_state(gc);
-
-	if (gc->hidden)
-		_group_show(gc);
-	else {
-		_group_hide(gc);
-		if (TAILQ_EMPTY(&gc->clients))
-			Group_active = gc;
-	}
-
-#ifdef notyet
-	snprintf(buf, sizeof(buf), "Group %d", idx + 1);
-	screen_infomsg(buf);
-#endif
-}
-
-#define GROUP_NEXT(gc, fwd) (fwd) ?					\
-	TAILQ_NEXT(gc, entry) : TAILQ_PREV(gc, group_ctx_q, entry)
-
-/*
- * Jump to the next/previous active group.  If none exist, then just
- * stay put.
- */
-void
-group_slide(int fwd)
-{
-	struct group_ctx *gc, *showgroup = NULL;
-
-	assert(Group_active != NULL);
-
-	gc = Group_active;
+	newgc = oldgc;
 	for (;;) {
-		gc = GROUP_NEXT(gc, fwd);
-		if (gc == NULL)
-			gc = fwd ? TAILQ_FIRST(&Groupq) :
-			    TAILQ_LAST(&Groupq, group_ctx_q);
-		if (gc == Group_active)
+		newgc = (flags & CWM_CYCLE_REVERSE) ? group_prev(newgc) :
+		    group_next(newgc);
+
+		if (newgc == oldgc)
 			break;
 
-		if (!TAILQ_EMPTY(&gc->clients) && showgroup == NULL)
-			showgroup = gc;
-		else if (!gc->hidden)
-			_group_hide(gc);
+		if (!group_holds_only_sticky(newgc) && showgroup == NULL)
+			showgroup = newgc;
+		else if (!group_holds_only_hidden(newgc))
+			group_hide(newgc);
 	}
-
 	if (showgroup == NULL)
 		return;
 
-	_group_hide(Group_active);
+	group_hide(oldgc);
 
-	if (showgroup->hidden)
-		_group_show(showgroup);
+	if (group_holds_only_hidden(showgroup))
+		group_show(showgroup);
 	else
-		Group_active = showgroup;
+		group_set_active(showgroup);
 }
 
-/* called when a client is deleted */
-void
-group_client_delete(struct client_ctx *cc)
+static struct group_ctx *
+group_next(struct group_ctx *gc)
 {
-	if (cc->group == NULL)
-	  	return;
+	struct screen_ctx	*sc = gc->sc;
+	struct group_ctx	*newgc;
 
-	TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
-	cc->group = NULL; /* he he */
-	cc->groupcommit = 0;
+	return(((newgc = TAILQ_NEXT(gc, entry)) != NULL) ?
+	    newgc : TAILQ_FIRST(&sc->groupq));
 }
 
-void
-group_menu(XButtonEvent *e)
+static struct group_ctx *
+group_prev(struct group_ctx *gc)
 {
-  	struct menu_q menuq;
-	struct menu  *mi;
-	int i;
-	struct group_ctx *gc;
+	struct screen_ctx	*sc = gc->sc;
+	struct group_ctx	*newgc;
 
-	TAILQ_INIT(&menuq);
+	return(((newgc = TAILQ_PREV(gc, group_q, entry)) != NULL) ?
+	    newgc : TAILQ_LAST(&sc->groupq, group_q));
+}
 
-	for (i = 0; i < CALMWM_NGROUPS; i++) {
-		gc = &Groups[i];
+int
+group_restore(struct client_ctx *cc)
+{
+	struct screen_ctx	*sc = cc->sc;
+	struct group_ctx	*gc;
+	int			 num;
+	long			 grpnum;
 
-		if (TAILQ_EMPTY(&gc->clients))
-			continue;
+	if (!xu_ewmh_get_net_wm_desktop(cc, &grpnum))
+		return 0;
 
-		if (gc->name == NULL)
-			gc->name = xstrdup(shortcut_to_name[gc->shortcut]);
+	num = (grpnum == -1) ? 0 : grpnum;
+	num = MIN(num, (Conf.ngroups - 1));
 
-		XCALLOC(mi, struct menu);
-		if (gc->hidden)
-			snprintf(mi->text, sizeof(mi->text), "%d: [%s]",
-			   gc->shortcut, gc->name); 
-		else
-			snprintf(mi->text, sizeof(mi->text), "%d: %s",
-			   gc->shortcut, gc->name); 
-		mi->ctx = gc;
-		TAILQ_INSERT_TAIL(&menuq, mi, entry);
-	}
-
-	if (TAILQ_EMPTY(&menuq))
-		return;
-
-	mi = (struct menu *)grab_menu(e, &menuq);
-
-	if (mi == NULL || mi->ctx == NULL)
-		goto cleanup;
-
-	gc = (struct group_ctx *)mi->ctx;
-
-	if (gc->hidden)
-		_group_show(gc);
-	else
-		_group_hide(gc);
-
- cleanup:
-	while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
-		TAILQ_REMOVE(&menuq, mi, entry);
-		xfree(mi);
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == num) {
+			group_assign(gc, cc);
+			return 1;
+		}
 	}
+	return 0;
 }
 
-void
-group_namemode(void)
-{
-	Groupnamemode = 1;
-
-	group_display_draw(screen_current());
-}
-
-void
-group_alltoggle(void)
-{
-	int i;
-
-	for (i=0; i < CALMWM_NGROUPS; i++) {
-		if (Grouphideall)
-			_group_show(&Groups[i]);
-		else
-		  	_group_hide(&Groups[i]);
-	}
-
-	if (Grouphideall)
-		Grouphideall = 0;
-	else
-		Grouphideall = 1;
-}
-
-void
-group_deletecurrent(void)
-{
-	_group_destroy(Group_current);
-	XUnmapWindow(X_Dpy, screen_current()->groupwin);
-
-  	Groupmode = Groupnamemode = 0;
-}
-
-void
-group_done(void)
-{
-	struct group_ctx *gc = Group_current;
-
-	if (gc->name != NULL)
-		xfree(gc->name);
-
-	gc->name = xstrdup(shortcut_to_name[gc->shortcut]);
-
-	group_exit(1);
-}
-
-void
+int
 group_autogroup(struct client_ctx *cc)
 {
-	struct autogroupwin *aw;
-	struct group_ctx *gc;
-	char group[CALMWM_MAXNAMELEN];
+	struct screen_ctx	*sc = cc->sc;
+	struct autogroup	*ag;
+	struct group_ctx	*gc;
+	int			 num = -1, both_match = 0;
 
-	if (cc->app_class == NULL || cc->app_name == NULL)
-		return;
+	if (cc->res_class == NULL || cc->res_name == NULL)
+		return 0;
 
-	TAILQ_FOREACH(aw, &Conf.autogroupq, entry) {
-		if (strcmp(aw->class, cc->app_class) == 0 &&
-		    (aw->name == NULL || strcmp(aw->name, cc->app_name) == 0)) {
-			strlcpy(group, aw->group, sizeof(group));
-			break;
+	TAILQ_FOREACH(ag, &Conf.autogroupq, entry) {
+		if (strcmp(ag->class, cc->res_class) == 0) {
+			if ((ag->name != NULL) &&
+			    (strcmp(ag->name, cc->res_name) == 0)) {
+				num = ag->num;
+				both_match = 1;
+			} else if (ag->name == NULL && !both_match)
+				num = ag->num;
 		}
 	}
 
-	TAILQ_FOREACH(gc, &Groupq, entry) {
-		if (strcmp(shortcut_to_name[gc->shortcut], group) == 0)
-			_group_add(gc, cc);
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == num) {
+			group_assign(gc, cc);
+			return 1;
+		}
 	}
-
+	return 0;
 }

hash.h

@@ -1,68 +0,0 @@
-/*
- * hash.h - generic hash template, akin to queue.h & tree.h
- *
- * Copyright (c) 2005 Marius Eriksen <marius@monkey.org>
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-
-#ifndef _HASH_H_		/* Possibly this is too generic. */
-#define _HASH_H_
-
-#include <sys/tree.h>
-
-#define HASH_ENTRY SPLAY_ENTRY
-
-#define HASH_HEAD(name, type, nbuckets) 			\
-	SPLAY_HEAD(name##_HASH_TREE, type);			\
-	struct name {						\
-		struct name##_HASH_TREE buckets[nbuckets];	\
-		unsigned int (*hashfn)(struct type *elm);	\
-	};
-
-#define HASH_NBUCKETS(head)					\
-	(sizeof((head)->buckets)/sizeof((head)->buckets[0]))
-
-#define HASH_INIT(head, fn) do {			\
-	int i;						\
-	for (i = 0; i < HASH_NBUCKETS(head); i++) {	\
-		SPLAY_INIT(&(head)->buckets[i]);	\
-	}						\
-	(head)->hashfn = fn;				\
-} while (0)
-
-#define HASH_PROTOTYPE(name, type, field, cmp)				\
-SPLAY_PROTOTYPE(name##_HASH_TREE, type, field, cmp)			\
-struct type *name##_HASH_TREE_FIND(struct name *head, struct type *find); \
-void name##_HASH_TREE_INSERT(struct name *head, struct type *insert);
-
-#define HASH_GENERATE(name, type, field, cmp)				\
-SPLAY_GENERATE(name##_HASH_TREE, type, field, cmp)			\
-struct type *name##_HASH_TREE_FIND(struct name *head, struct type *find) \
-{									\
-	struct name##_HASH_TREE *bucket =				\
-	    &head->buckets[(*head->hashfn)(find) % HASH_NBUCKETS(head)]; \
-	return SPLAY_FIND(name##_HASH_TREE, bucket, find);		\
-}									\
-void name##_HASH_TREE_INSERT(struct name *head, struct type *insert)	\
-{									\
-	struct name##_HASH_TREE *bucket =				\
-	    &head->buckets[(*head->hashfn)(insert) % HASH_NBUCKETS(head)]; \
-									\
-	SPLAY_INSERT(name##_HASH_TREE, bucket, insert);			\
-}
-
-#define HASH_FIND(name, head, find) name##_HASH_TREE_FIND((head), (find))
-#define HASH_INSERT(name, head, insert) name##_HASH_TREE_INSERT((head), (insert))
-
-#endif /* _HASH_H_ */

headers.h

@@ -1,44 +0,0 @@
-/*
- * calmwm - the calm window manager
- *
- * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
- *
- * $Id$
- */
-
-#ifndef _CALMWM_HEADERS_H_
-#define _CALMWM_HEADERS_H_
-
-#include <sys/types.h>
-
-#include <sys/queue.h>
-#include <sys/wait.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <dirent.h>
-#include <getopt.h>
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <ctype.h>
-
-#include <X11/cursorfont.h>
-#include <X11/extensions/shape.h>
-#include <X11/Xlib.h>  
-#include <X11/Xutil.h>
-#include <X11/keysym.h>
-#include <X11/Xatom.h>
-#include <X11/Xproto.h>
-#include <X11/Intrinsic.h>
-#include <X11/Xos.h>
-#include <X11/Xft/Xft.h>
-
-#include <err.h>
-
-#endif /* _CALMWM_HEADERS_H_ */

input.c

@@ -1,84 +0,0 @@
-/*
- * calmwm - the calm window manager
- *
- * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
- *
- * $Id$
- */
-
-#include "headers.h"
-#include "calmwm.h"
-
-int
-input_keycodetrans(KeyCode kc, u_int state,
-    enum ctltype *ctl, char *chr, int normalize)
-{
-	int ks;
-
-	*ctl = CTL_NONE;
-	*chr = '\0';
-
-	if (state & ShiftMask)
-		ks = XKeycodeToKeysym(X_Dpy, kc, 1);
-	else
-		ks = XKeycodeToKeysym(X_Dpy, kc, 0);
-
-	/* Look for control characters. */
-	switch (ks) {
-	case XK_BackSpace:
-		*ctl = CTL_ERASEONE;
-		break;
-	case XK_Return:
-		*ctl = CTL_RETURN;
-		break;
-	case XK_Up:
-		*ctl = CTL_UP;
-		break;
-	case XK_Down:
-		*ctl = CTL_DOWN;
-		break;
-	case XK_Escape:
-		*ctl = CTL_ABORT;
-		break;
-	}
-
-	if (*ctl == CTL_NONE && (state & ControlMask)) {
-		switch (ks) {
-		case XK_s:
-		case XK_S:
-			/* Emacs "next" */
-			*ctl = CTL_DOWN;
-			break;
-		case XK_r:
-		case XK_R:
-			/* Emacs "previous" */
-			*ctl = CTL_UP;
-			break;
-		case XK_u:
-		case XK_U:
-			*ctl = CTL_WIPE;
-			break;
-		case XK_a:
-		case XK_A:
-			*ctl = CTL_ALL;
-			break;
-		}
-	}
-
-	if (*ctl != CTL_NONE)
-		return (0);
-
-	/*
-	 * For regular characters, only (part of, actually) Latin 1
-	 * for now.
-	 */
-	if (ks < 0x20 || ks > 0x07e)
-		return (-1);
-
-	*chr = (char)ks;
-	if (normalize)
-		*chr = tolower(*chr);
-
-	return (0);
-}

menu.c

@@ -0,0 +1,619 @@
+/*
+ * calmwm - the calm window manager
+ *
+ * Copyright (c) 2008 Owain G. Ainsworth <oga@openbsd.org>
+ * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
+ */
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "calmwm.h"
+
+#define PROMPT_SCHAR	"\xc2\xbb"
+#define PROMPT_ECHAR	"\xc2\xab"
+
+#define MENUMASK 	(MOUSEMASK | ButtonMotionMask | KeyPressMask | \
+			 ExposureMask)
+#define MENUGRABMASK	(MOUSEMASK | ButtonMotionMask | StructureNotifyMask)
+
+enum ctltype {
+	CTL_NONE = -1,
+	CTL_ERASEONE = 0, CTL_WIPE, CTL_UP, CTL_DOWN, CTL_RETURN,
+	CTL_TAB, CTL_ABORT, CTL_ALL
+};
+
+struct menu_ctx {
+	struct screen_ctx	*sc;
+	Window			 win;
+	XftDraw			*xftdraw;
+	struct geom		 geom;
+	char			 searchstr[MENU_MAXENTRY + 1];
+	char			 dispstr[MENU_MAXENTRY*2 + 1];
+	char			 promptstr[MENU_MAXENTRY + 1];
+	int			 list;
+	int			 listing;
+	int			 changed;
+	int			 prev;
+	int			 entry;
+	int			 num;
+	int 			 flags;
+	void (*match)(struct menu_q *, struct menu_q *, char *);
+	void (*print)(struct menu *, int);
+};
+static struct menu	*menu_handle_key(XEvent *, struct menu_ctx *,
+			     struct menu_q *, struct menu_q *);
+static void		 menu_handle_move(struct menu_ctx *,
+			     struct menu_q *, int, int);
+static struct menu	*menu_handle_release(struct menu_ctx *,
+			     struct menu_q *, int, int);
+static void		 menu_draw(struct menu_ctx *, struct menu_q *,
+			     struct menu_q *);
+static void 		 menu_draw_entry(struct menu_ctx *, struct menu_q *,
+			     int, int);
+static int		 menu_calc_entry(struct menu_ctx *, int, int);
+static struct menu	*menu_complete_path(struct menu_ctx *);
+static int		 menu_keycode(XKeyEvent *, enum ctltype *, char *);
+
+struct menu *
+menu_filter(struct screen_ctx *sc, struct menu_q *menuq, const char *prompt,
+    const char *initial, int flags,
+    void (*match)(struct menu_q *, struct menu_q *, char *),
+    void (*print)(struct menu *, int))
+{
+	struct menu_ctx		 mc;
+	struct menu_q		 resultq;
+	struct menu		*mi = NULL;
+	XEvent			 e;
+	Window			 focuswin;
+	int			 focusrevert, xsave, ysave, xcur, ycur;
+
+	TAILQ_INIT(&resultq);
+
+	xu_ptr_get(sc->rootwin, &xsave, &ysave);
+
+	(void)memset(&mc, 0, sizeof(mc));
+	mc.sc = sc;
+	mc.flags = flags;
+	mc.match = match;
+	mc.print = print;
+	mc.entry = mc.prev = -1;
+	mc.geom.x = xsave;
+	mc.geom.y = ysave;
+
+	if (mc.flags & CWM_MENU_LIST)
+		mc.list = 1;
+
+	(void)strlcpy(mc.promptstr, prompt, sizeof(mc.promptstr));
+	if (initial != NULL)
+		(void)strlcpy(mc.searchstr, initial, sizeof(mc.searchstr));
+	else
+		mc.searchstr[0] = '\0';
+
+	mc.win = XCreateSimpleWindow(X_Dpy, sc->rootwin, 0, 0, 1, 1,
+	    Conf.bwidth,
+	    sc->xftcolor[CWM_COLOR_MENU_FG].pixel,
+	    sc->xftcolor[CWM_COLOR_MENU_BG].pixel);
+	mc.xftdraw = XftDrawCreate(X_Dpy, mc.win,
+	    sc->visual, sc->colormap);
+
+	XSelectInput(X_Dpy, mc.win, MENUMASK);
+	XMapRaised(X_Dpy, mc.win);
+
+	if (XGrabPointer(X_Dpy, mc.win, False, MENUGRABMASK,
+	    GrabModeAsync, GrabModeAsync, None, Conf.cursor[CF_QUESTION],
+	    CurrentTime) != GrabSuccess) {
+		XftDrawDestroy(mc.xftdraw);
+		XDestroyWindow(X_Dpy, mc.win);
+		return NULL;
+	}
+
+	XGetInputFocus(X_Dpy, &focuswin, &focusrevert);
+	XSetInputFocus(X_Dpy, mc.win, RevertToPointerRoot, CurrentTime);
+
+	/* make sure keybindings don't remove keys from the menu stream */
+	XGrabKeyboard(X_Dpy, mc.win, True,
+	    GrabModeAsync, GrabModeAsync, CurrentTime);
+
+	for (;;) {
+		mc.changed = 0;
+
+		XWindowEvent(X_Dpy, mc.win, MENUMASK, &e);
+
+		switch (e.type) {
+		case KeyPress:
+			if ((mi = menu_handle_key(&e, &mc, menuq, &resultq))
+			    != NULL)
+				goto out;
+			/* FALLTHROUGH */
+		case Expose:
+			menu_draw(&mc, menuq, &resultq);
+			break;
+		case MotionNotify:
+			menu_handle_move(&mc, &resultq,
+			    e.xbutton.x, e.xbutton.y);
+			break;
+		case ButtonRelease:
+			if ((mi = menu_handle_release(&mc, &resultq,
+			    e.xbutton.x, e.xbutton.y)) != NULL)
+				goto out;
+			break;
+		default:
+			break;
+		}
+	}
+out:
+	if ((mc.flags & CWM_MENU_DUMMY) == 0 && mi->dummy) {
+	       	/* no mouse based match */
+		free(mi);
+		mi = NULL;
+	}
+
+	XftDrawDestroy(mc.xftdraw);
+	XDestroyWindow(X_Dpy, mc.win);
+
+	XSetInputFocus(X_Dpy, focuswin, focusrevert, CurrentTime);
+	/* restore if user didn't move */
+	xu_ptr_get(sc->rootwin, &xcur, &ycur);
+	if (xcur == mc.geom.x && ycur == mc.geom.y)
+		xu_ptr_set(sc->rootwin, xsave, ysave);
+
+	XUngrabPointer(X_Dpy, CurrentTime);
+	XUngrabKeyboard(X_Dpy, CurrentTime);
+
+	return mi;
+}
+
+static struct menu *
+menu_complete_path(struct menu_ctx *mc)
+{
+	struct screen_ctx	*sc = mc->sc;
+	struct menu		*mi, *mr;
+	struct menu_q		 menuq;
+	int			 mflags = (CWM_MENU_DUMMY);
+
+	mr = xcalloc(1, sizeof(*mr));
+
+	TAILQ_INIT(&menuq);
+
+	if ((mi = menu_filter(sc, &menuq, mc->searchstr, NULL, mflags,
+	    search_match_path, search_print_text)) != NULL) {
+		mr->abort = mi->abort;
+		mr->dummy = mi->dummy;
+		if (mi->text[0] != '\0')
+			snprintf(mr->text, sizeof(mr->text), "%s \"%s\"",
+			    mc->searchstr, mi->text);
+		else if (!mr->abort)
+			strlcpy(mr->text, mc->searchstr, sizeof(mr->text));
+	}
+	
+	menuq_clear(&menuq);
+
+	return mr;
+}
+
+static struct menu *
+menu_handle_key(XEvent *e, struct menu_ctx *mc, struct menu_q *menuq,
+    struct menu_q *resultq)
+{
+	struct menu	*mi;
+	enum ctltype	 ctl;
+	char		 chr[32];
+	size_t		 len;
+	int 		 clen, i;
+	wchar_t 	 wc;
+
+	if (menu_keycode(&e->xkey, &ctl, chr) < 0)
+		return NULL;
+
+	switch (ctl) {
+	case CTL_ERASEONE:
+		if ((len = strlen(mc->searchstr)) > 0) {
+			clen = 1;
+			while (mbtowc(&wc, &mc->searchstr[len-clen], MB_CUR_MAX) == -1)
+				clen++;
+			for (i = 1; i <= clen; i++)
+				mc->searchstr[len - i] = '\0';
+			mc->changed = 1;
+		}
+		break;
+	case CTL_UP:
+		mi = TAILQ_LAST(resultq, menu_q);
+		if (mi == NULL)
+			break;
+
+		TAILQ_REMOVE(resultq, mi, resultentry);
+		TAILQ_INSERT_HEAD(resultq, mi, resultentry);
+		break;
+	case CTL_DOWN:
+		mi = TAILQ_FIRST(resultq);
+		if (mi == NULL)
+			break;
+
+		TAILQ_REMOVE(resultq, mi, resultentry);
+		TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+		break;
+	case CTL_RETURN:
+		/*
+		 * Return whatever the cursor is currently on. Else
+		 * even if dummy is zero, we need to return something.
+		 */
+		if ((mi = TAILQ_FIRST(resultq)) == NULL) {
+			mi = xmalloc(sizeof(*mi));
+			(void)strlcpy(mi->text,
+			    mc->searchstr, sizeof(mi->text));
+			mi->dummy = 1;
+		}
+		mi->abort = 0;
+		return mi;
+	case CTL_WIPE:
+		mc->searchstr[0] = '\0';
+		mc->changed = 1;
+		break;
+	case CTL_TAB:
+		if ((mi = TAILQ_FIRST(resultq)) != NULL) {
+			/*
+			 * - We are in exec_path menu mode
+			 * - It is equal to the input
+			 * We got a command, launch the file menu
+			 */
+			if ((mc->flags & CWM_MENU_FILE) &&
+			    (strncmp(mc->searchstr, mi->text,
+					strlen(mi->text))) == 0)
+				return menu_complete_path(mc);
+
+			/*
+			 * Put common prefix of the results into searchstr
+			 */
+			(void)strlcpy(mc->searchstr,
+					mi->text, sizeof(mc->searchstr));
+			while ((mi = TAILQ_NEXT(mi, resultentry)) != NULL) {
+				i = 0;
+				while (tolower(mc->searchstr[i]) ==
+					       tolower(mi->text[i]))
+					i++;
+				mc->searchstr[i] = '\0';
+			}
+			mc->changed = 1;
+		}
+		break;
+	case CTL_ALL:
+		mc->list = !mc->list;
+		break;
+	case CTL_ABORT:
+		mi = xmalloc(sizeof(*mi));
+		mi->text[0] = '\0';
+		mi->dummy = 1;
+		mi->abort = 1;
+		return mi;
+	default:
+		break;
+	}
+
+	if (chr[0] != '\0') {
+		mc->changed = 1;
+		(void)strlcat(mc->searchstr, chr, sizeof(mc->searchstr));
+	}
+
+	if (mc->changed) {
+		if (mc->searchstr[0] != '\0')
+			(*mc->match)(menuq, resultq, mc->searchstr);
+	} else if (!mc->list && mc->listing) {
+		TAILQ_INIT(resultq);
+		mc->listing = 0;
+	}
+
+	return NULL;
+}
+
+static void
+menu_draw(struct menu_ctx *mc, struct menu_q *menuq, struct menu_q *resultq)
+{
+	struct screen_ctx	*sc = mc->sc;
+	struct menu		*mi;
+	struct geom		 area;
+	int			 n, xsave, ysave;
+	XGlyphInfo		 extents;
+
+	if (mc->list) {
+		if (TAILQ_EMPTY(resultq)) {
+			/* Copy them all over. */
+			TAILQ_FOREACH(mi, menuq, entry)
+				TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+
+			mc->listing = 1;
+		} else if (mc->changed)
+			mc->listing = 0;
+	}
+
+	(void)snprintf(mc->dispstr, sizeof(mc->dispstr), "%s%s%s%s",
+	    mc->promptstr, PROMPT_SCHAR, mc->searchstr, PROMPT_ECHAR);
+	XftTextExtentsUtf8(X_Dpy, sc->xftfont,
+	    (const FcChar8*)mc->dispstr, strlen(mc->dispstr), &extents);
+	mc->geom.w = extents.xOff;
+	mc->geom.h = sc->xftfont->ascent + sc->xftfont->descent;
+	mc->num = 1;
+
+	TAILQ_FOREACH(mi, resultq, resultentry) {
+		(*mc->print)(mi, mc->listing);
+		XftTextExtentsUtf8(X_Dpy, sc->xftfont,
+		    (const FcChar8*)mi->print,
+		    MIN(strlen(mi->print), MENU_MAXENTRY), &extents);
+		mc->geom.w = MAX(mc->geom.w, extents.xOff);
+		mc->geom.h += sc->xftfont->ascent + sc->xftfont->descent;
+		mc->num++;
+	}
+
+	area = screen_area(sc, mc->geom.x, mc->geom.y, 1);
+	area.w += area.x - Conf.bwidth * 2;
+	area.h += area.y - Conf.bwidth * 2;
+
+	xsave = mc->geom.x;
+	ysave = mc->geom.y;
+
+	/* Never hide the top, or left side, of the menu. */
+	if (mc->geom.x + mc->geom.w >= area.w)
+		mc->geom.x = area.w - mc->geom.w;
+	if (mc->geom.x < area.x) {
+		mc->geom.x = area.x;
+		mc->geom.w = MIN(mc->geom.w, (area.w - area.x));
+	}
+	if (mc->geom.y + mc->geom.h >= area.h)
+		mc->geom.y = area.h - mc->geom.h;
+	if (mc->geom.y < area.y) {
+		mc->geom.y = area.y;
+		mc->geom.h = MIN(mc->geom.h, (area.h - area.y));
+	}
+
+	if (mc->geom.x != xsave || mc->geom.y != ysave)
+		xu_ptr_set(sc->rootwin, mc->geom.x, mc->geom.y);
+
+	XClearWindow(X_Dpy, mc->win);
+	XMoveResizeWindow(X_Dpy, mc->win, mc->geom.x, mc->geom.y,
+	    mc->geom.w, mc->geom.h);
+
+	n = 1;
+	XftDrawStringUtf8(mc->xftdraw,
+	    &sc->xftcolor[CWM_COLOR_MENU_FONT], sc->xftfont,
+	    0, sc->xftfont->ascent,
+	    (const FcChar8*)mc->dispstr, strlen(mc->dispstr));
+
+	TAILQ_FOREACH(mi, resultq, resultentry) {
+		int y = n * (sc->xftfont->ascent + sc->xftfont->descent);
+
+		/* Stop drawing when menu doesn't fit inside the screen. */
+		if (mc->geom.y + y >= area.h)
+			break;
+
+		XftDrawStringUtf8(mc->xftdraw,
+		    &sc->xftcolor[CWM_COLOR_MENU_FONT], sc->xftfont,
+		    0, y + sc->xftfont->ascent,
+		    (const FcChar8*)mi->print, strlen(mi->print));
+		n++;
+	}
+	if (n > 1)
+		menu_draw_entry(mc, resultq, 1, 1);
+}
+
+static void
+menu_draw_entry(struct menu_ctx *mc, struct menu_q *resultq,
+    int entry, int active)
+{
+	struct screen_ctx	*sc = mc->sc;
+	struct menu		*mi;
+	int			 color, i = 1, y;
+
+	TAILQ_FOREACH(mi, resultq, resultentry)
+		if (entry == i++)
+			break;
+	if (mi == NULL)
+		return;
+
+	y = entry * (sc->xftfont->ascent + sc->xftfont->descent);
+	color = (active) ? CWM_COLOR_MENU_FG : CWM_COLOR_MENU_BG;
+	XftDrawRect(mc->xftdraw, &sc->xftcolor[color], 0, y,
+	    mc->geom.w, sc->xftfont->ascent + sc->xftfont->descent);
+	color = (active) ? CWM_COLOR_MENU_FONT_SEL : CWM_COLOR_MENU_FONT;
+	XftDrawStringUtf8(mc->xftdraw,
+	    &sc->xftcolor[color], sc->xftfont, 0, y + sc->xftfont->ascent,
+	    (const FcChar8*)mi->print, strlen(mi->print));
+}
+
+static void
+menu_handle_move(struct menu_ctx *mc, struct menu_q *resultq, int x, int y)
+{
+	mc->prev = mc->entry;
+	mc->entry = menu_calc_entry(mc, x, y);
+
+	if (mc->prev == mc->entry)
+		return;
+
+	if (mc->prev != -1)
+		menu_draw_entry(mc, resultq, mc->prev, 0);
+	if (mc->entry != -1) {
+		XChangeActivePointerGrab(X_Dpy, MENUGRABMASK,
+		    Conf.cursor[CF_NORMAL], CurrentTime);
+		menu_draw_entry(mc, resultq, mc->entry, 1);
+	}
+}
+
+static struct menu *
+menu_handle_release(struct menu_ctx *mc, struct menu_q *resultq, int x, int y)
+{
+	struct menu		*mi;
+	int			 entry, i = 1;
+
+	entry = menu_calc_entry(mc, x, y);
+
+	TAILQ_FOREACH(mi, resultq, resultentry)
+		if (entry == i++)
+			break;
+	if (mi == NULL) {
+		mi = xmalloc(sizeof(*mi));
+		mi->text[0] = '\0';
+		mi->dummy = 1;
+	}
+	return mi;
+}
+
+static int
+menu_calc_entry(struct menu_ctx *mc, int x, int y)
+{
+	struct screen_ctx	*sc = mc->sc;
+	int			 entry;
+
+	entry = y / (sc->xftfont->ascent + sc->xftfont->descent);
+
+	/* in bounds? */
+	if (x < 0 || x > mc->geom.w || y < 0 ||
+	    y > (sc->xftfont->ascent + sc->xftfont->descent) * mc->num ||
+	    entry < 0 || entry >= mc->num)
+		entry = -1;
+
+	if (entry == 0)
+		entry = -1;
+
+	return entry;
+}
+
+static int
+menu_keycode(XKeyEvent *ev, enum ctltype *ctl, char *chr)
+{
+	KeySym		 ks;
+
+	*ctl = CTL_NONE;
+	chr[0] = '\0';
+
+	ks = XkbKeycodeToKeysym(X_Dpy, ev->keycode, 0,
+	     (ev->state & ShiftMask) ? 1 : 0);
+
+	/* Look for control characters. */
+	switch (ks) {
+	case XK_BackSpace:
+		*ctl = CTL_ERASEONE;
+		break;
+	case XK_KP_Enter:
+	case XK_Return:
+		*ctl = CTL_RETURN;
+		break;
+	case XK_Tab:
+		*ctl = CTL_TAB;
+		break;
+	case XK_Up:
+		*ctl = CTL_UP;
+		break;
+	case XK_Down:
+		*ctl = CTL_DOWN;
+		break;
+	case XK_Escape:
+		*ctl = CTL_ABORT;
+		break;
+	}
+
+	if (*ctl == CTL_NONE && (ev->state & ControlMask)) {
+		switch (ks) {
+		case XK_s:
+		case XK_S:
+			/* Emacs "next" */
+			*ctl = CTL_DOWN;
+			break;
+		case XK_r:
+		case XK_R:
+			/* Emacs "previous" */
+			*ctl = CTL_UP;
+			break;
+		case XK_u:
+		case XK_U:
+			*ctl = CTL_WIPE;
+			break;
+		case XK_h:
+		case XK_H:
+			*ctl = CTL_ERASEONE;
+			break;
+		case XK_a:
+		case XK_A:
+			*ctl = CTL_ALL;
+			break;
+		case XK_bracketleft:
+			*ctl = CTL_ABORT;
+			break;
+		}
+	}
+
+	if (*ctl == CTL_NONE && (ev->state & Mod1Mask)) {
+		switch (ks) {
+		case XK_j:
+		case XK_J:
+			/* Vi "down" */
+			*ctl = CTL_DOWN;
+			break;
+		case XK_k:
+		case XK_K:
+			/* Vi "up" */
+			*ctl = CTL_UP;
+			break;
+		}
+	}
+
+	if (*ctl != CTL_NONE)
+		return 0;
+
+	if (XLookupString(ev, chr, 32, &ks, NULL) < 0)
+		return -1;
+
+	return 0;
+}
+
+void
+menuq_add(struct menu_q *mq, void *ctx, const char *fmt, ...)
+{
+	va_list		 ap;
+	struct menu	*mi;
+
+	mi = xcalloc(1, sizeof(*mi));
+	mi->ctx = ctx;
+
+	va_start(ap, fmt);
+	if (fmt != NULL)
+		(void)vsnprintf(mi->text, sizeof(mi->text), fmt, ap);
+	else
+		mi->text[0] = '\0';
+	va_end(ap);
+
+	TAILQ_INSERT_TAIL(mq, mi, entry);
+}
+
+void
+menuq_clear(struct menu_q *mq)
+{
+	struct menu	*mi;
+
+	while ((mi = TAILQ_FIRST(mq)) != NULL) {
+		TAILQ_REMOVE(mq, mi, entry);
+		free(mi);
+	}
+}

parse.y

@@ -0,0 +1,639 @@
+/*	$OpenBSD$ */
+
+/*
+ * Copyright (c) 2002, 2003, 2004 Henning Brauer <henning@openbsd.org>
+ * Copyright (c) 2001 Markus Friedl.  All rights reserved.
+ * Copyright (c) 2001 Daniel Hartmeier.  All rights reserved.
+ * Copyright (c) 2001 Theo de Raadt.  All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+%{
+
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "calmwm.h"
+
+TAILQ_HEAD(files, file)		 files = TAILQ_HEAD_INITIALIZER(files);
+static struct file {
+	TAILQ_ENTRY(file)	 entry;
+	FILE			*stream;
+	char			*name;
+	int			 lineno;
+	int			 errors;
+} *file, *topfile;
+struct file	*pushfile(const char *, FILE *);
+int		 popfile(void);
+int		 yyparse(void);
+int		 yylex(void);
+int		 yyerror(const char *, ...)
+    __attribute__((__format__ (printf, 1, 2)))
+    __attribute__((__nonnull__ (1)));
+int		 kw_cmp(const void *, const void *);
+int		 lookup(char *);
+int		 lgetc(int);
+int		 lungetc(int);
+int		 findeol(void);
+
+static struct conf	*conf;
+
+typedef struct {
+	union {
+		int64_t			 number;
+		char			*string;
+	} v;
+	int lineno;
+} YYSTYPE;
+
+%}
+
+%token	BINDKEY UNBINDKEY BINDMOUSE UNBINDMOUSE
+%token	FONTNAME STICKY GAP
+%token	AUTOGROUP COMMAND IGNORE WM
+%token	YES NO BORDERWIDTH MOVEAMOUNT HTILE VTILE
+%token	COLOR SNAPDIST
+%token	ACTIVEBORDER INACTIVEBORDER URGENCYBORDER
+%token	GROUPBORDER UNGROUPBORDER
+%token	MENUBG MENUFG
+%token	FONTCOLOR FONTSELCOLOR
+%token	ERROR
+%token	<v.string>		STRING
+%token	<v.number>		NUMBER
+%type	<v.number>		yesno
+%type	<v.string>		string numberstring
+%%
+
+grammar		: /* empty */
+		| grammar '\n'
+		| grammar main '\n'
+		| grammar color '\n'
+		| grammar error '\n'		{ file->errors++; }
+		;
+
+string		: string STRING			{
+			if (asprintf(&$$, "%s %s", $1, $2) == -1) {
+				free($1);
+				free($2);
+				yyerror("string: asprintf");
+				YYERROR;
+			}
+			free($1);
+			free($2);
+		}
+		| STRING
+		;
+
+numberstring	: NUMBER				{
+			char	*s;
+			if (asprintf(&s, "%lld", $1) == -1) {
+				yyerror("string: asprintf");
+				YYERROR;
+			}
+			$$ = s;
+		}
+		| STRING
+		;
+
+yesno		: YES				{ $$ = 1; }
+		| NO				{ $$ = 0; }
+		;
+
+main		: FONTNAME STRING		{
+			free(conf->font);
+			conf->font = $2;
+		}
+		| STICKY yesno {
+			conf->stickygroups = $2;
+		}
+		| BORDERWIDTH NUMBER {
+			if ($2 < 0 || $2 > INT_MAX) {
+				yyerror("invalid borderwidth");
+				YYERROR;
+			}
+			conf->bwidth = $2;
+		}
+		| HTILE NUMBER {
+			if ($2 < 0 || $2 > 99) {
+				yyerror("invalid htile percent");
+				YYERROR;
+			}
+			conf->htile = $2;
+		}
+		| VTILE NUMBER {
+			if ($2 < 0 || $2 > 99) {
+				yyerror("invalid vtile percent");
+				YYERROR;
+			}
+			conf->vtile = $2;
+		}
+		| MOVEAMOUNT NUMBER {
+			if ($2 < 0 || $2 > INT_MAX) {
+				yyerror("invalid movemount");
+				YYERROR;
+			}
+			conf->mamount = $2;
+		}
+		| SNAPDIST NUMBER {
+			if ($2 < 0 || $2 > INT_MAX) {
+				yyerror("invalid snapdist");
+				YYERROR;
+			}
+			conf->snapdist = $2;
+		}
+		| COMMAND STRING string		{
+			if (strlen($3) >= PATH_MAX) {
+				yyerror("%s command path too long", $2);
+				free($2);
+				free($3);
+				YYERROR;
+			}
+			conf_cmd_add(conf, $2, $3);
+			free($2);
+			free($3);
+		}
+		| WM STRING string	{
+			if (strlen($3) >= PATH_MAX) {
+				yyerror("%s wm path too long", $2);
+				free($2);
+				free($3);
+				YYERROR;
+			}
+			conf_wm_add(conf, $2, $3);
+			free($2);
+			free($3);
+		}
+		| AUTOGROUP NUMBER STRING	{
+			if ($2 < 0 || $2 > 9) {
+				yyerror("invalid autogroup");
+				free($3);
+				YYERROR;
+			}
+			conf_autogroup(conf, $2, NULL, $3);
+			free($3);
+		}
+		| AUTOGROUP NUMBER STRING ',' STRING {
+			if ($2 < 0 || $2 > 9) {
+				yyerror("invalid autogroup");
+				free($3);
+				free($5);
+				YYERROR;
+			}
+			conf_autogroup(conf, $2, $3, $5);
+			free($3);
+			free($5);
+		}
+		| IGNORE STRING {
+			conf_ignore(conf, $2);
+			free($2);
+		}
+		| GAP NUMBER NUMBER NUMBER NUMBER {
+			if ($2 < 0 || $2 > INT_MAX ||
+			    $3 < 0 || $3 > INT_MAX ||
+			    $4 < 0 || $4 > INT_MAX ||
+			    $5 < 0 || $5 > INT_MAX) {
+				yyerror("invalid gap");
+				YYERROR;
+			}
+			conf->gap.top = $2;
+			conf->gap.bottom = $3;
+			conf->gap.left = $4;
+			conf->gap.right = $5;
+		}
+		| BINDKEY numberstring string {
+			if (!conf_bind_key(conf, $2, $3)) {
+				yyerror("invalid bind-key: %s %s", $2, $3);
+				free($2);
+				free($3);
+				YYERROR;
+			}
+			free($2);
+			free($3);
+		}
+		| UNBINDKEY numberstring {
+			if (!conf_bind_key(conf, $2, NULL)) {
+				yyerror("invalid unbind-key: %s", $2);
+				free($2);
+				YYERROR;
+			}
+			free($2);
+		}
+		| BINDMOUSE numberstring string {
+			if (!conf_bind_mouse(conf, $2, $3)) {
+				yyerror("invalid bind-mouse: %s %s", $2, $3);
+				free($2);
+				free($3);
+				YYERROR;
+			}
+			free($2);
+			free($3);
+		}
+		| UNBINDMOUSE numberstring {
+			if (!conf_bind_mouse(conf, $2, NULL)) {
+				yyerror("invalid unbind-mouse: %s", $2);
+				free($2);
+				YYERROR;
+			}
+			free($2);
+		}
+		;
+
+color		: COLOR colors
+		;
+
+colors		: ACTIVEBORDER STRING {
+			free(conf->color[CWM_COLOR_BORDER_ACTIVE]);
+			conf->color[CWM_COLOR_BORDER_ACTIVE] = $2;
+		}
+		| INACTIVEBORDER STRING {
+			free(conf->color[CWM_COLOR_BORDER_INACTIVE]);
+			conf->color[CWM_COLOR_BORDER_INACTIVE] = $2;
+		}
+		| URGENCYBORDER STRING {
+			free(conf->color[CWM_COLOR_BORDER_URGENCY]);
+			conf->color[CWM_COLOR_BORDER_URGENCY] = $2;
+		}
+		| GROUPBORDER STRING {
+			free(conf->color[CWM_COLOR_BORDER_GROUP]);
+			conf->color[CWM_COLOR_BORDER_GROUP] = $2;
+		}
+		| UNGROUPBORDER STRING {
+			free(conf->color[CWM_COLOR_BORDER_UNGROUP]);
+			conf->color[CWM_COLOR_BORDER_UNGROUP] = $2;
+		}
+		| MENUBG STRING {
+			free(conf->color[CWM_COLOR_MENU_BG]);
+			conf->color[CWM_COLOR_MENU_BG] = $2;
+		}
+		| MENUFG STRING {
+			free(conf->color[CWM_COLOR_MENU_FG]);
+			conf->color[CWM_COLOR_MENU_FG] = $2;
+		}
+		| FONTCOLOR STRING {
+			free(conf->color[CWM_COLOR_MENU_FONT]);
+			conf->color[CWM_COLOR_MENU_FONT] = $2;
+		}
+		| FONTSELCOLOR STRING {
+			free(conf->color[CWM_COLOR_MENU_FONT_SEL]);
+			conf->color[CWM_COLOR_MENU_FONT_SEL] = $2;
+		}
+		;
+%%
+
+struct keywords {
+	const char	*k_name;
+	int		 k_val;
+};
+
+int
+yyerror(const char *fmt, ...)
+{
+	va_list		 ap;
+
+	file->errors++;
+	va_start(ap, fmt);
+	fprintf(stderr, "%s:%d: ", file->name, yylval.lineno);
+	vfprintf(stderr, fmt, ap);
+	fprintf(stderr, "\n");
+	va_end(ap);
+	return (0);
+}
+
+int
+kw_cmp(const void *k, const void *e)
+{
+	return (strcmp(k, ((const struct keywords *)e)->k_name));
+}
+
+int
+lookup(char *s)
+{
+	/* this has to be sorted always */
+	static const struct keywords keywords[] = {
+		{ "activeborder",	ACTIVEBORDER},
+		{ "autogroup",		AUTOGROUP},
+		{ "bind-key",		BINDKEY},
+		{ "bind-mouse",		BINDMOUSE},
+		{ "borderwidth",	BORDERWIDTH},
+		{ "color",		COLOR},
+		{ "command",		COMMAND},
+		{ "font",		FONTCOLOR},
+		{ "fontname",		FONTNAME},
+		{ "gap",		GAP},
+		{ "groupborder",	GROUPBORDER},
+		{ "htile",		HTILE},
+		{ "ignore",		IGNORE},
+		{ "inactiveborder",	INACTIVEBORDER},
+		{ "menubg",		MENUBG},
+		{ "menufg",		MENUFG},
+		{ "moveamount",		MOVEAMOUNT},
+		{ "no",			NO},
+		{ "selfont", 		FONTSELCOLOR},
+		{ "snapdist",		SNAPDIST},
+		{ "sticky",		STICKY},
+		{ "unbind-key",		UNBINDKEY},
+		{ "unbind-mouse",	UNBINDMOUSE},
+		{ "ungroupborder",	UNGROUPBORDER},
+		{ "urgencyborder",	URGENCYBORDER},
+		{ "vtile",		VTILE},
+		{ "wm",			WM},
+		{ "yes",		YES}
+	};
+	const struct keywords	*p;
+
+	p = bsearch(s, keywords, sizeof(keywords)/sizeof(keywords[0]),
+	    sizeof(keywords[0]), kw_cmp);
+
+	if (p)
+		return (p->k_val);
+	else
+		return (STRING);
+}
+
+#define MAXPUSHBACK	128
+
+char	*parsebuf;
+int	 parseindex;
+char	 pushback_buffer[MAXPUSHBACK];
+int	 pushback_index = 0;
+
+int
+lgetc(int quotec)
+{
+	int		c, next;
+
+	if (parsebuf) {
+		/* Read character from the parsebuffer instead of input. */
+		if (parseindex >= 0) {
+			c = (unsigned char)parsebuf[parseindex++];
+			if (c != '\0')
+				return (c);
+			parsebuf = NULL;
+		} else
+			parseindex++;
+	}
+
+	if (pushback_index)
+		return ((unsigned char)pushback_buffer[--pushback_index]);
+
+	if (quotec) {
+		if ((c = getc(file->stream)) == EOF) {
+			yyerror("reached end of file while parsing "
+			    "quoted string");
+			if (file == topfile || popfile() == EOF)
+				return (EOF);
+			return (quotec);
+		}
+		return (c);
+	}
+
+	while ((c = getc(file->stream)) == '\\') {
+		next = getc(file->stream);
+		if (next != '\n') {
+			c = next;
+			break;
+		}
+		yylval.lineno = file->lineno;
+		file->lineno++;
+	}
+
+	while (c == EOF) {
+		if (file == topfile || popfile() == EOF)
+			return (EOF);
+		c = getc(file->stream);
+	}
+	return (c);
+}
+
+int
+lungetc(int c)
+{
+	if (c == EOF)
+		return (EOF);
+	if (parsebuf) {
+		parseindex--;
+		if (parseindex >= 0)
+			return (c);
+	}
+	if (pushback_index + 1 >= MAXPUSHBACK)
+		return (EOF);
+	pushback_buffer[pushback_index++] = c;
+	return (c);
+}
+
+int
+findeol(void)
+{
+	int	c;
+
+	parsebuf = NULL;
+
+	/* skip to either EOF or the first real EOL */
+	while (1) {
+		if (pushback_index)
+			c = (unsigned char)pushback_buffer[--pushback_index];
+		else
+			c = lgetc(0);
+		if (c == '\n') {
+			file->lineno++;
+			break;
+		}
+		if (c == EOF)
+			break;
+	}
+	return (ERROR);
+}
+
+int
+yylex(void)
+{
+	char	 buf[8096];
+	char	*p;
+	int	 quotec, next, c;
+	int	 token;
+
+	p = buf;
+	while ((c = lgetc(0)) == ' ' || c == '\t')
+		; /* nothing */
+
+	yylval.lineno = file->lineno;
+	if (c == '#')
+		while ((c = lgetc(0)) != '\n' && c != EOF)
+			; /* nothing */
+
+	switch (c) {
+	case '\'':
+	case '"':
+		quotec = c;
+		while (1) {
+			if ((c = lgetc(quotec)) == EOF)
+				return (0);
+			if (c == '\n') {
+				file->lineno++;
+				continue;
+			} else if (c == '\\') {
+				if ((next = lgetc(quotec)) == EOF)
+					return (0);
+				if (next == quotec || next == ' ' ||
+				    next == '\t')
+					c = next;
+				else if (next == '\n') {
+					file->lineno++;
+					continue;
+				} else
+					lungetc(next);
+			} else if (c == quotec) {
+				*p = '\0';
+				break;
+			} else if (c == '\0') {
+				yyerror("syntax error");
+				return (findeol());
+			}
+			if (p + 1 >= buf + sizeof(buf) - 1) {
+				yyerror("string too long");
+				return (findeol());
+			}
+			*p++ = c;
+		}
+		yylval.v.string = xstrdup(buf);
+		return (STRING);
+	}
+
+#define allowed_to_end_number(x) \
+	(isspace(x) || x == ')' || x ==',' || x == '/' || x == '}' || x == '=')
+
+	if (c == '-' || isdigit(c)) {
+		do {
+			*p++ = c;
+			if ((size_t)(p-buf) >= sizeof(buf)) {
+				yyerror("string too long");
+				return (findeol());
+			}
+		} while ((c = lgetc(0)) != EOF && isdigit(c));
+		lungetc(c);
+		if (p == buf + 1 && buf[0] == '-')
+			goto nodigits;
+		if (c == EOF || allowed_to_end_number(c)) {
+			const char *errstr = NULL;
+
+			*p = '\0';
+			yylval.v.number = strtonum(buf, LLONG_MIN,
+			    LLONG_MAX, &errstr);
+			if (errstr) {
+				yyerror("\"%s\" invalid number: %s",
+				    buf, errstr);
+				return (findeol());
+			}
+			return (NUMBER);
+		} else {
+nodigits:
+			while (p > buf + 1)
+				lungetc((unsigned char)*--p);
+			c = (unsigned char)*--p;
+			if (c == '-')
+				return (c);
+		}
+	}
+
+/* Similar to other parse.y copies, but also allows '/' in strings */
+#define allowed_in_string(x) \
+	(isalnum(x) || (ispunct(x) && x != '(' && x != ')' && \
+	x != '{' && x != '}' && x != '<' && x != '>' && \
+	x != '!' && x != '=' && x != '#' && x != ','))
+
+	if (isalnum(c) || c == ':' || c == '_' || c == '*' || c == '/') {
+		do {
+			*p++ = c;
+			if ((size_t)(p-buf) >= sizeof(buf)) {
+				yyerror("string too long");
+				return (findeol());
+			}
+		} while ((c = lgetc(0)) != EOF && (allowed_in_string(c)));
+		lungetc(c);
+		*p = '\0';
+		if ((token = lookup(buf)) == STRING)
+			yylval.v.string = xstrdup(buf);
+		return (token);
+	}
+	if (c == '\n') {
+		yylval.lineno = file->lineno;
+		file->lineno++;
+	}
+	if (c == EOF)
+		return (0);
+	return (c);
+}
+
+struct file *
+pushfile(const char *name, FILE *stream)
+{
+	struct file	*nfile;
+
+	nfile = xcalloc(1, sizeof(struct file));
+	nfile->name = xstrdup(name);
+	nfile->stream = stream;
+	nfile->lineno = 1;
+	TAILQ_INSERT_TAIL(&files, nfile, entry);
+	return (nfile);
+}
+
+int
+popfile(void)
+{
+	struct file	*prev;
+
+	if ((prev = TAILQ_PREV(file, files, entry)) != NULL)
+		prev->errors += file->errors;
+
+	TAILQ_REMOVE(&files, file, entry);
+	fclose(file->stream);
+	free(file->name);
+	free(file);
+	file = prev;
+	return (file ? 0 : EOF);
+}
+
+int
+parse_config(const char *filename, struct conf *xconf)
+{
+	FILE		*stream;
+	int		 errors = 0;
+
+	conf = xconf;
+
+	stream = fopen(filename, "r");
+	if (stream == NULL) {
+		if (errno == ENOENT)
+			return (0);
+		warn("%s", filename);
+		return (-1);
+	}
+	file = pushfile(filename, stream);
+	topfile = file;
+
+	yyparse();
+	errors = file->errors;
+	popfile();
+
+	return (errors ? -1 : 0);
+}

screen.c

@@ -2,102 +2,306 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-extern struct screen_ctx_q	Screenq;
-extern struct screen_ctx       *Curscreen;
+static struct geom screen_apply_gap(struct screen_ctx *, struct geom);
+static void screen_scan(struct screen_ctx *);
+
+void
+screen_init(int which)
+{
+	struct screen_ctx	*sc;
+	XSetWindowAttributes	 attr;
+
+	sc = xmalloc(sizeof(*sc));
+
+	TAILQ_INIT(&sc->clientq);
+	TAILQ_INIT(&sc->regionq);
+	TAILQ_INIT(&sc->groupq);
+
+	sc->which = which;
+	sc->rootwin = RootWindow(X_Dpy, sc->which);
+	sc->colormap = DefaultColormap(X_Dpy, sc->which);
+	sc->visual = DefaultVisual(X_Dpy, sc->which);
+	sc->cycling = 0;
+	sc->hideall = 0;
+
+	conf_screen(sc);
+
+	xu_ewmh_net_supported(sc);
+	xu_ewmh_net_supported_wm_check(sc);
+
+	conf_group(sc);
+	sc->group_last = sc->group_active;
+	screen_update_geometry(sc);
+
+	xu_ewmh_net_desktop_names(sc);
+	xu_ewmh_net_number_of_desktops(sc);
+	xu_ewmh_net_showing_desktop(sc);
+	xu_ewmh_net_virtual_roots(sc);
+
+	attr.cursor = Conf.cursor[CF_NORMAL];
+	attr.event_mask = SubstructureRedirectMask | SubstructureNotifyMask |
+	    EnterWindowMask | PropertyChangeMask | ButtonPressMask;
+	XChangeWindowAttributes(X_Dpy, sc->rootwin, (CWEventMask | CWCursor), &attr);
+
+	if (Conf.xrandr)
+		XRRSelectInput(X_Dpy, sc->rootwin, RRScreenChangeNotifyMask);
+
+	screen_scan(sc);
+	screen_updatestackingorder(sc);
+
+	TAILQ_INSERT_TAIL(&Screenq, sc, entry);
+
+	XSync(X_Dpy, False);
+}
 
 static void
-_clearwindow_cb(int sig)
+screen_scan(struct screen_ctx *sc)
 {
-	struct screen_ctx *sc = screen_current();
-	XUnmapWindow(X_Dpy, sc->infowin);
+	struct client_ctx	 *cc, *active = NULL;
+	Window			*wins, w0, w1, rwin, cwin;
+	unsigned int		 nwins, i, mask;
+	int			 rx, ry, wx, wy;
+
+	XQueryPointer(X_Dpy, sc->rootwin, &rwin, &cwin,
+	    &rx, &ry, &wx, &wy, &mask);
+
+	if (XQueryTree(X_Dpy, sc->rootwin, &w0, &w1, &wins, &nwins)) {
+		for (i = 0; i < nwins; i++) {
+			if ((cc = client_init(wins[i], sc)) != NULL)
+				if (cc->win == cwin)
+					active = cc;
+		}
+		XFree(wins);
+	}
+	if (active)
+		client_set_active(active);
 }
 
 struct screen_ctx *
-screen_fromroot(Window rootwin)
+screen_find(Window win)
 {
-	struct screen_ctx *sc;
+	struct screen_ctx	*sc;
 
-	TAILQ_FOREACH(sc, &Screenq, entry)
-		if (sc->rootwin == rootwin)
-			return (sc);
-
-	/* XXX FAIL HERE */
-	return (TAILQ_FIRST(&Screenq));
-}
-
-struct screen_ctx *
-screen_current(void)
-{
-	return (Curscreen);
+	TAILQ_FOREACH(sc, &Screenq, entry) {
+		if (sc->rootwin == win)
+			return sc;
+	}
+	warnx("%s: failure win 0x%lx", __func__, win);
+	return NULL;
 }
 
 void
-screen_updatestackingorder(void)
+screen_updatestackingorder(struct screen_ctx *sc)
 {
-	Window *wins, w0, w1;
-	struct screen_ctx *sc = screen_current();
-	u_int nwins, i, s;
-	struct client_ctx *cc;
+	Window			*wins, w0, w1;
+	struct client_ctx	*cc;
+	unsigned int		 nwins, i, s;
 
-	if (!XQueryTree(X_Dpy, sc->rootwin, &w0, &w1, &wins, &nwins))
-		return;
+	if (XQueryTree(X_Dpy, sc->rootwin, &w0, &w1, &wins, &nwins)) {
+		for (s = 0, i = 0; i < nwins; i++) {
+			/* Skip hidden windows */
+			if ((cc = client_find(wins[i])) == NULL ||
+			    cc->flags & CLIENT_HIDDEN)
+				continue;
 
-	for (s = 0, i = 0; i < nwins; i++) {
-		/* Skip hidden windows */
-		if ((cc = client_find(wins[i])) == NULL ||
-		    cc->flags & CLIENT_HIDDEN)
-			continue;
+			cc->stackingorder = s++;
+		}
+		XFree(wins);
+	}
+}
 
-		cc->stackingorder = s++;
+struct region_ctx *
+region_find(struct screen_ctx *sc, int x, int y)
+{
+	struct region_ctx	*rc;
+
+	TAILQ_FOREACH(rc, &sc->regionq, entry) {
+		if ((x >= rc->view.x) && (x < (rc->view.x + rc->view.w)) &&
+		    (y >= rc->view.y) && (y < (rc->view.y + rc->view.h))) {
+			break;
+		}
+	}
+	return rc;
+}
+
+struct geom
+screen_area(struct screen_ctx *sc, int x, int y, int apply_gap)
+{
+	struct region_ctx	*rc;
+	struct geom		 area = sc->view;
+
+	TAILQ_FOREACH(rc, &sc->regionq, entry) {
+		if ((x >= rc->view.x) && (x < (rc->view.x + rc->view.w)) &&
+		    (y >= rc->view.y) && (y < (rc->view.y + rc->view.h))) {
+			area = rc->view;
+			break;
+		}
+	}
+	if (apply_gap)
+		area = screen_apply_gap(sc, area);
+	return area;
+}
+
+void
+screen_update_geometry(struct screen_ctx *sc)
+{
+	struct region_ctx	*rc;
+
+	sc->view.x = 0;
+	sc->view.y = 0;
+	sc->view.w = DisplayWidth(X_Dpy, sc->which);
+	sc->view.h = DisplayHeight(X_Dpy, sc->which);
+	sc->work = screen_apply_gap(sc, sc->view);
+
+	while ((rc = TAILQ_FIRST(&sc->regionq)) != NULL) {
+		TAILQ_REMOVE(&sc->regionq, rc, entry);
+		free(rc);
 	}
 
-	XFree(wins);
+	if (Conf.xrandr) {
+		XRRScreenResources *sr;
+		XRRCrtcInfo *ci;
+		int i;
+
+		sr = XRRGetScreenResources(X_Dpy, sc->rootwin);
+		for (i = 0, ci = NULL; i < sr->ncrtc; i++) {
+			ci = XRRGetCrtcInfo(X_Dpy, sr, sr->crtcs[i]);
+			if (ci == NULL)
+				continue;
+			if (ci->noutput == 0) {
+				XRRFreeCrtcInfo(ci);
+				continue;
+			}
+
+			rc = xmalloc(sizeof(*rc));
+			rc->num = i;
+			rc->view.x = ci->x;
+			rc->view.y = ci->y;
+			rc->view.w = ci->width;
+			rc->view.h = ci->height;
+			rc->work = screen_apply_gap(sc, rc->view);
+			TAILQ_INSERT_TAIL(&sc->regionq, rc, entry);
+
+			XRRFreeCrtcInfo(ci);
+		}
+		XRRFreeScreenResources(sr);
+	} else {
+		rc = xmalloc(sizeof(*rc));
+		rc->num = 0;
+		rc->view.x = 0;
+		rc->view.y = 0;
+		rc->view.w = DisplayWidth(X_Dpy, sc->which);
+		rc->view.h = DisplayHeight(X_Dpy, sc->which);
+		rc->work = screen_apply_gap(sc, rc->view);
+		TAILQ_INSERT_TAIL(&sc->regionq, rc, entry);
+	}
+
+	xu_ewmh_net_desktop_geometry(sc);
+	xu_ewmh_net_desktop_viewport(sc);
+	xu_ewmh_net_workarea(sc);
+}
+
+static struct geom
+screen_apply_gap(struct screen_ctx *sc, struct geom geom)
+{
+	geom.x += sc->gap.left;
+	geom.y += sc->gap.top;
+	geom.w -= (sc->gap.left + sc->gap.right);
+	geom.h -= (sc->gap.top + sc->gap.bottom);
+
+	return geom;
+}
+
+/* Bring back clients which are beyond the screen. */
+void
+screen_assert_clients_within(struct screen_ctx *sc)
+{
+	struct client_ctx	*cc;
+	int			 top, left, right, bottom;
+
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->sc != sc)
+			continue;
+		top = cc->geom.y;
+		left = cc->geom.x;
+		right = cc->geom.x + cc->geom.w + (cc->bwidth * 2) - 1;
+		bottom = cc->geom.y + cc->geom.h + (cc->bwidth * 2) - 1;
+		if ((top > sc->view.h || left > sc->view.w) ||
+		    (bottom < 0 || right < 0)) {
+			cc->geom.x = sc->gap.left;
+			cc->geom.y = sc->gap.top;
+			client_move(cc);
+		}
+	}
 }
 
 void
-screen_init(void)
+screen_prop_win_create(struct screen_ctx *sc, Window win)
 {
+	sc->prop.win = XCreateSimpleWindow(X_Dpy, win, 0, 0, 1, 1, 0,
+	    sc->xftcolor[CWM_COLOR_MENU_BG].pixel,
+	    sc->xftcolor[CWM_COLOR_MENU_BG].pixel);
+	sc->prop.xftdraw = XftDrawCreate(X_Dpy, sc->prop.win,
+	    sc->visual, sc->colormap);
 
-	struct screen_ctx *sc = screen_current();
-
-	sc->cycle_client = NULL;
-
-	sc->infowin = XCreateSimpleWindow(X_Dpy, sc->rootwin, 0, 0,
-	    1, 1, 1, sc->blackpixl, sc->whitepixl);
-
-	/* XXX - marius. */
-	if (signal(SIGALRM, _clearwindow_cb) == SIG_ERR)
-		err(1, "signal");
+	XMapWindow(X_Dpy, sc->prop.win);
 }
 
 void
-screen_infomsg(char *msg)
+screen_prop_win_destroy(struct screen_ctx *sc)
 {
-	struct screen_ctx *sc = screen_current();
-	char buf[1024];
-	int dy, dx;
-	struct fontdesc *font = DefaultFont;
-
-	XUnmapWindow(X_Dpy, sc->infowin);
-	alarm(0);
-
-	snprintf(buf, sizeof(buf), ">%s", msg);
-	dy = font_ascent(font) + font_descent(font) + 1;
-	dx = font_width(font, buf, strlen(buf));
-
-	XMoveResizeWindow(X_Dpy, sc->infowin, 0, 0, dx, dy);
-	XMapRaised(X_Dpy, sc->infowin);
-
-	font_draw(font, buf, strlen(buf), sc->infowin,
-	    0, font_ascent(font) + 1);
-
-	alarm(1);
+	XftDrawDestroy(sc->prop.xftdraw);
+	XDestroyWindow(X_Dpy, sc->prop.win);
+}
+
+void
+screen_prop_win_draw(struct screen_ctx *sc, const char *fmt, ...)
+{
+	va_list			 ap;
+	char			*text;
+	XGlyphInfo		 extents;
+
+	va_start(ap, fmt);
+	xvasprintf(&text, fmt, ap);
+	va_end(ap);
+
+	XftTextExtentsUtf8(X_Dpy, sc->xftfont, (const FcChar8*)text,
+	    strlen(text), &extents);
+	XResizeWindow(X_Dpy, sc->prop.win, extents.xOff, sc->xftfont->height);
+	XClearWindow(X_Dpy, sc->prop.win);
+	XftDrawStringUtf8(sc->prop.xftdraw, &sc->xftcolor[CWM_COLOR_MENU_FONT],
+	    sc->xftfont, 0, sc->xftfont->ascent + 1,
+	    (const FcChar8*)text, strlen(text));
+
+	free(text);
 }

search.c

@@ -2,364 +2,112 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <fnmatch.h>
+#include <glob.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-#define SearchMask (KeyPressMask|ExposureMask)
+#define PATH_ANY 	0x0001
+#define PATH_EXEC 	0x0002
 
-static int  _strsubmatch(char *, char *, int);
+static void	match_path_type(struct menu_q *, char *, int);
+static int	match_substr(char *, char *, int);
 
-void
-search_init(struct screen_ctx *sc)
+static int
+match_substr(char *sub, char *str, int zeroidx)
 {
-	sc->searchwin = XCreateSimpleWindow(X_Dpy, sc->rootwin, 0, 0,
-	    1, 1, 1, sc->blackpixl, sc->whitepixl);
+	size_t		 len, sublen;
+	unsigned int	 n, flen;
+
+	if (sub == NULL || str == NULL)
+		return 0;
+
+	len = strlen(str);
+	sublen = strlen(sub);
+
+	if (sublen > len)
+		return 0;
+
+	if (zeroidx)
+		flen = 0;
+	else
+		flen = len - sublen;
+
+	for (n = 0; n <= flen; n++)
+		if (strncasecmp(sub, str + n, sublen) == 0)
+			return 1;
+
+	return 0;
 }
 
-/*
- * ranking.  each rank type is assigned a weight.  multiply this by
- * the rank given.  add them up.  simple linear combination.
- */
-
-/*
- * Input: list of items,
- * Output: choose one
- * so, exactly like menus
- */
-
-struct menu *
-search_start(struct menu_q *menuq,
-    void (*match)(struct menu_q *, struct menu_q *, char *), 
-    void (*rank)(struct menu_q *resultq, char *search), 
-    void (*print)(struct menu *mi, int print),
-    char *prompt, int dummy)
-{
-	struct screen_ctx *sc = screen_current();
-	int x, y, dx, dy, fontheight,
-	    focusrevert, mutated, xmax, ymax, warp, added, beobnoxious = 0;
-	XEvent e;
-	char searchstr[MENU_MAXENTRY + 1];
-	char dispstr[MENU_MAXENTRY*2 + 1];
-	char promptstr[MENU_MAXENTRY + 1];
-	Window focuswin;
-	struct menu *mi = NULL, *dummy_mi = NULL;
-	struct menu_q resultq;
-	char chr;
-	enum ctltype ctl;
-	size_t len;
-	u_int n;
-	static int list = 0;
-	int listing = 0;
-	char endchar = '<EFBFBD>';
-	struct fontdesc *font = DefaultFont;
-
-	if (prompt == NULL)
-		prompt = "search";
-
-	TAILQ_INIT(&resultq);
-
-	xmax = DisplayWidth(X_Dpy, sc->which);
-	ymax = DisplayHeight(X_Dpy, sc->which);
-
-	xu_ptr_getpos(sc->rootwin, &x, &y);
-
-	searchstr[0] = '\0';
-
-	snprintf(promptstr, sizeof(promptstr), "%s <20>", prompt);
-	dy = fontheight = font_ascent(font) + font_descent(font) + 1;
-	snprintf(dispstr, sizeof(dispstr), "%s%c", promptstr, endchar);
-	dx = font_width(font, dispstr, strlen(dispstr));
-
-	XMoveResizeWindow(X_Dpy, sc->searchwin, x, y, dx, dy);
-	XSelectInput(X_Dpy, sc->searchwin, SearchMask);
-	XMapRaised(X_Dpy, sc->searchwin);
-
-	/*
-	 * TODO: eventually, the mouse should be able to select
-	 * results as well.  Right now we grab it only to set a fancy
-	 * cursor.
-	 */
-	if (xu_ptr_grab(sc->searchwin, 0, Cursor_question) < 0) {
-		XUnmapWindow(X_Dpy, sc->searchwin);
-		return (NULL);
-	}
-
-	XGetInputFocus(X_Dpy, &focuswin, &focusrevert);
-	XSetInputFocus(X_Dpy, sc->searchwin, RevertToPointerRoot, CurrentTime);
-
-	for (;;) {
-		added = mutated = 0;
-
-		XMaskEvent(X_Dpy, SearchMask, &e);
-
-		switch (e.type) {
-		case KeyPress:
-			/*
-			 * XXX - C-s & C-r for next and prev.
-			 */
-
-			if (input_keycodetrans(e.xkey.keycode, e.xkey.state,
-				&ctl, &chr, 1) < 0)
-				continue;
-
-			switch (ctl) {
-			case CTL_ERASEONE:
-				if ((len = strlen(searchstr)) > 0) {
-					searchstr[len - 1] = '\0';
-					mutated = 1;
-				}
-				break;
-			case CTL_UP:
-				mi = TAILQ_LAST(&resultq, menu_q);
-				if (mi == NULL)
-					break;
-
-				TAILQ_REMOVE(&resultq, mi, resultentry);
-				TAILQ_INSERT_HEAD(&resultq, mi, resultentry);
-				break;
-			case CTL_DOWN:
-				mi = TAILQ_FIRST(&resultq);
-				if (mi == NULL)
-					break;
-
-				TAILQ_REMOVE(&resultq, mi, resultentry);
-				TAILQ_INSERT_TAIL(&resultq, mi, resultentry);
-				break;
-			case CTL_RETURN:
-				/* This is just picking the match the
-				 * cursor is over. */
-				if ((mi = TAILQ_FIRST(&resultq)) != NULL) {
-					goto found;
-				} else if (dummy) {
-					dummy_mi = xmalloc(sizeof *dummy_mi);
-					(void) strlcpy(dummy_mi->text,
-					    searchstr, sizeof(dummy_mi->text));
-					dummy_mi->dummy = 1;
-					goto found;
-				}
-				goto out;
-			case CTL_WIPE:
-				searchstr[0] = '\0';
-				mutated = 1;
-				break;
-			case CTL_ALL:
-				list = !list;
-				break;
-			case CTL_ABORT:
-				goto out;
-			default:
-				break;
-			}
-
-			if (chr != '\0') {
-				char str[2];
-
-				str[0] = chr;
-				str[1] = '\0';
-				mutated = 1;
-				added =
-				    strlcat(searchstr, str, sizeof(searchstr));
-			}
-
-			beobnoxious = 0;
-			if (mutated && strlen(searchstr) > 0) {
-				(*match)(menuq, &resultq, searchstr);
-				beobnoxious = TAILQ_EMPTY(&resultq);
-				if (!beobnoxious && rank != NULL)
-					(*rank)(&resultq, searchstr);
-			} else if (mutated)
-				TAILQ_INIT(&resultq);
-
-
-			 if (!list && listing && !mutated) {
-				TAILQ_INIT(&resultq);
-				listing = 0;
-			}
-
-		case Expose:
-			if (list) {
-				if (TAILQ_EMPTY(&resultq) && list) {
-					/* Copy them over and rank them. */
-					TAILQ_FOREACH(mi, menuq, entry)
-					    TAILQ_INSERT_TAIL(&resultq, mi,
-						resultentry);
-					if (rank != NULL)
-						(*rank)(&resultq, searchstr);
-
-					listing = 1;
-				} else if (mutated)
-					listing = 0;
-			}
-
-			snprintf(dispstr, sizeof(dispstr), "%s%s%c",
-			    promptstr, searchstr, endchar);
-			dx = font_width(font, dispstr, strlen(dispstr));
-			dy = fontheight;
-
-			TAILQ_FOREACH(mi, &resultq, resultentry) {
-				char *text;
-
-				if (print != NULL) {
-					(*print)(mi, listing);
-					text = mi->print;
-				} else {
-					mi->print[0] = '\0';
-					text = mi->text;
-				}
-
-				dx = MAX(dx, font_width(font, text,
-					MIN(strlen(text), MENU_MAXENTRY)));
-				dy += fontheight;
-			}
-
-			/*
-			 * Calculate new geometry.
-			 *
-			 * XXX - put this into a util function -- it's
-			 * used elsewhere, too.
-			 */
-			warp = 0;
-			if (x < 0) {
-				x = 0;
-				warp = 1;
-			}
-			if (x + dx >= xmax) {
-				x = xmax - dx;
-				warp = 1;
-			}
-
-			if (y < 0) {
-				y = 0;
-				warp = 1;
-			}
-			if (y + dy >= ymax) {
-				y = ymax - dy;
-				warp = 1;
-			}
-
-			if (warp)
-				xu_ptr_setpos(sc->rootwin, x, y);
-
-			XClearWindow(X_Dpy, sc->searchwin);
-			XMoveResizeWindow(X_Dpy, sc->searchwin, x, y, dx, dy);
-
-			font_draw(font, dispstr, strlen(dispstr), sc->searchwin,
-			    0, font_ascent(font) + 1);
-
-			n = 1;
-			TAILQ_FOREACH(mi, &resultq, resultentry) {
-				char *text = mi->print[0] != '\0' ?
-				    mi->print : mi->text;
-
-				font_draw(font, text,
-				    MIN(strlen(text), MENU_MAXENTRY),
-				    sc->searchwin,
-				    0, n*fontheight + font_ascent(font) + 1);
-				n++;
-			}
-
-			if (n > 1)
-				XFillRectangle(X_Dpy, sc->searchwin, sc->gc,
-				    0, fontheight, dx, fontheight);
-
-			if (beobnoxious)
-				XFillRectangle(X_Dpy, sc->searchwin, sc->gc,
-				    0, 0, dx, fontheight);
-
-			break;
-		}
-	}
-
-out:
-	/* (if no match) */
-	xu_ptr_ungrab();
-	XSetInputFocus(X_Dpy, focuswin, focusrevert, CurrentTime);
-
-found:
-	XUnmapWindow(X_Dpy, sc->searchwin);
-
-	if (dummy && dummy_mi != NULL)
-		return (dummy_mi);
-	return (mi);
-}
-
-/*
- * Match: label, title, class.
- */
-
 void
 search_match_client(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct winname *wn;
-	struct menu *mi, *tierp[4], *before = NULL;
-	int ntiers = sizeof(tierp)/sizeof(tierp[0]);
+	struct menu		*mi, *tierp[3], *before = NULL;
+	struct client_ctx	*cc;
+	struct winname		*wn;
+
+	(void)memset(tierp, 0, sizeof(tierp));
 
 	TAILQ_INIT(resultq);
-
-	memset(tierp, 0, sizeof(tierp));
-
-	/*
-	 * In order of rank:
-	 *
-	 *   1. Look through labels.
-	 *   2. Look at title history, from present to past.
-	 *   3. Look at window class name.
-	 */
-
 	TAILQ_FOREACH(mi, menuq, entry) {
 		int tier = -1, t;
-		struct client_ctx *cc = mi->ctx;
+		cc = (struct client_ctx *)mi->ctx;
 
-		/* First, try to match on labels. */
-		if (cc->label != NULL && _strsubmatch(search, cc->label, 0)) {
-			cc->matchname = cc->label;
+		/* Match on label. */
+		if (match_substr(search, cc->label, 0))
 			tier = 0;
-		} 
 
-		/* Then, on window names. */
+		/* Match on window name history, from present to past. */
 		if (tier < 0) {
-			TAILQ_FOREACH_REVERSE(wn, &cc->nameq, winname_q, entry)
-			    if (_strsubmatch(search, wn->name, 0)) {
-				    cc->matchname = wn->name;
-				    tier = 2;
-				    break;
-			    }
+			TAILQ_FOREACH_REVERSE(wn, &cc->nameq, name_q, entry)
+				if (match_substr(search, wn->name, 0)) {
+					tier = 1;
+					break;
+				}
 		}
 
-		/*
-		 * See if there is a match on the window class
-		 * name.
-		 */
-
-		if (tier < 0 && _strsubmatch(search, cc->app_class, 0)) {
-			cc->matchname = cc->app_class;
-			tier = 3;
-		}
+		/* Match on window resource class. */
+		if ((tier < 0) && match_substr(search, cc->res_class, 0))
+			tier = 2;
 
 		if (tier < 0)
 			continue;
 
-		/*
-		 * De-rank a client one tier if it's the current
-		 * window.  Furthermore, this is denoted by a "!" when
-		 * printing the window name in the search menu.
-		 */
-		if (cc == client_current() && tier < ntiers - 1)
+		/* Current window is ranked down. */
+		if ((tier < nitems(tierp) - 1) && (cc->flags & CLIENT_ACTIVE))
 			tier++;
 
-		/*
-		 * Clients that are hidden get ranked one up.
-		 */
-		if (cc->flags & CLIENT_HIDDEN && tier > 0)
+		/* Hidden window is ranked up. */
+		if ((tier > 0) && (cc->flags & CLIENT_HIDDEN))
 			tier--;
 
-		assert(tier < ntiers);
-
 		/*
 		 * If you have a tierp, insert after it, and make it
 		 * the new tierp.  If you don't have a tierp, find the
@@ -367,7 +115,6 @@ search_match_client(struct menu_q *menuq, struct menu_q *resultq, char *search)
 		 * Always make your current tierp the newly inserted
 		 * entry.
 		 */
-
 		for (t = tier; t >= 0 && ((before = tierp[t]) == NULL); t--)
 			;
 
@@ -381,95 +128,162 @@ search_match_client(struct menu_q *menuq, struct menu_q *resultq, char *search)
 }
 
 void
-search_print_client(struct menu *mi, int list)
+search_match_cmd(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct client_ctx *cc = mi->ctx;
-	char flag = ' ';
+	struct menu		*mi;
+	struct cmd_ctx		*cmd;
 
-	if (cc == client_current())
-		flag = '!';
-	else if (cc->flags & CLIENT_HIDDEN)
-		flag = '&';
-
-	if (list)
-		cc->matchname = TAILQ_FIRST(&cc->nameq)->name;
-
-	snprintf(mi->print, sizeof(mi->print), "%c%s", flag, cc->matchname);
-
-	if (!list && cc->matchname != cc->name &&
-	    strlen(mi->print) < sizeof(mi->print) - 1) {
-		int diff = sizeof(mi->print) - 1 - strlen(mi->print);
-		const char *marker = "";
-		char buf[MENU_MAXENTRY + 1];
-
-		/* One for the ':' */
-		diff -= 1;
-
-		if (strlen(cc->name) > diff) {
-			marker = "..";
-			diff -= 2;
-		} else {
-			diff = strlen(cc->name);
-		}
-
-		strlcpy(buf, mi->print, sizeof(buf));
-		snprintf(mi->print, sizeof(mi->print),
-		    "%s:%.*s%s", buf, diff, cc->name, marker);
+	TAILQ_INIT(resultq);
+	TAILQ_FOREACH(mi, menuq, entry) {
+		cmd = (struct cmd_ctx *)mi->ctx;
+		if (match_substr(search, cmd->name, 0))
+			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
 	}
 }
 
 void
-search_match_text(struct menu_q *menuq, struct menu_q *resultq, char *search)
+search_match_group(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct menu *mi;
+	struct menu		*mi;
+	struct group_ctx	*gc;
+	char			*s;
 
 	TAILQ_INIT(resultq);
-
-	TAILQ_FOREACH(mi, menuq, entry)
-		if (_strsubmatch(search, mi->text, 0))
+	TAILQ_FOREACH(mi, menuq, entry) {
+		gc = (struct group_ctx *)mi->ctx;
+		xasprintf(&s, "%d %s", gc->num, gc->name);
+		if (match_substr(search, s, 0))
 			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+		free(s);
+	}
+}
+
+static void
+match_path_type(struct menu_q *resultq, char *search, int flag)
+{
+	struct menu     *mi;
+	char 		*pattern;
+	glob_t		 g;
+	int		 i;
+
+	xasprintf(&pattern, "%s*", search);
+	if (glob(pattern, GLOB_MARK, NULL, &g) != 0)
+		return;
+	for (i = 0; i < g.gl_pathc; i++) {
+		if ((flag & PATH_EXEC) && access(g.gl_pathv[i], X_OK))
+			continue;
+		mi = xcalloc(1, sizeof(*mi));
+		(void)strlcpy(mi->text, g.gl_pathv[i], sizeof(mi->text));
+		TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+	}
+	globfree(&g);
+	free(pattern);
 }
 
 void
 search_match_exec(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct menu *mi;
+	struct menu	*mi, *mj;
+	int		 r;
 
 	TAILQ_INIT(resultq);
-
-	TAILQ_FOREACH(mi, menuq, entry)
-		if (_strsubmatch(search, mi->text, 1))
+	TAILQ_FOREACH(mi, menuq, entry) {
+		if (match_substr(search, mi->text, 1) == 0 &&
+		    fnmatch(search, mi->text, 0) == FNM_NOMATCH)
+			continue;
+		TAILQ_FOREACH(mj, resultq, resultentry) {
+			r = strcmp(mi->text, mj->text);
+			if (r < 0)
+				TAILQ_INSERT_BEFORE(mj, mi, resultentry);
+			if (r <= 0)
+				break;
+		}
+		if (mj == NULL)
 			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+	}
+	if (TAILQ_EMPTY(resultq))
+		match_path_type(resultq, search, PATH_EXEC);
 }
 
 void
-search_rank_text(struct menu_q *resultq, char *search)
+search_match_path(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	return;
+	TAILQ_INIT(resultq);
+	match_path_type(resultq, search, PATH_ANY);
 }
 
-static int
-_strsubmatch(char *sub, char *str, int zeroidx)
+void
+search_match_text(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	size_t len, sublen;
-	u_int n, flen;
+	struct menu	*mi;
 
-	if (sub == NULL || str == NULL)
-		return (0);
-
-	len = strlen(str);
-	sublen = strlen(sub);
-
-	if (sublen > len)
-		return (0);
-
-	if (!zeroidx)
-		flen = len - sublen;
-	else
-		flen = 0;
-	for (n = 0; n <= flen; n++)
-		if (strncasecmp(sub, str + n, sublen) == 0)
-			return (1);
-
-	return (0);
+	TAILQ_INIT(resultq);
+	TAILQ_FOREACH(mi, menuq, entry) {
+		if (match_substr(search, mi->text, 0))
+			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+	}
+}
+
+void
+search_match_wm(struct menu_q *menuq, struct menu_q *resultq, char *search)
+{
+	struct menu		*mi;
+	struct cmd_ctx		*wm;
+
+	TAILQ_INIT(resultq);
+	TAILQ_FOREACH(mi, menuq, entry) {
+		wm = (struct cmd_ctx *)mi->ctx;
+		if ((match_substr(search, wm->name, 0)) ||
+		    (match_substr(search, wm->path, 0)))
+			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+	}
+}
+
+void
+search_print_client(struct menu *mi, int listing)
+{
+	struct client_ctx	*cc = (struct client_ctx *)mi->ctx;
+	char			 flag = ' ';
+
+	if (cc->flags & CLIENT_ACTIVE)
+		flag = '!';
+	else if (cc->flags & CLIENT_HIDDEN)
+		flag = '&';
+
+	(void)snprintf(mi->print, sizeof(mi->print), "(%d) %c[%s] %s",
+	    (cc->gc) ? cc->gc->num : 0, flag,
+	    (cc->label) ? cc->label : "", cc->name);
+}
+
+void
+search_print_cmd(struct menu *mi, int listing)
+{
+	struct cmd_ctx		*cmd = (struct cmd_ctx *)mi->ctx;
+
+	(void)snprintf(mi->print, sizeof(mi->print), "%s", cmd->name);
+}
+
+void
+search_print_group(struct menu *mi, int listing)
+{
+	struct group_ctx	*gc = (struct group_ctx *)mi->ctx;
+
+	(void)snprintf(mi->print, sizeof(mi->print),
+	    (group_holds_only_hidden(gc)) ? "%d: [%s]" : "%d: %s",
+	    gc->num, gc->name);
+}
+
+void
+search_print_text(struct menu *mi, int listing)
+{
+	(void)snprintf(mi->print, sizeof(mi->print), "%s", mi->text);
+}
+
+void
+search_print_wm(struct menu *mi, int listing)
+{
+	struct cmd_ctx		*wm = (struct cmd_ctx *)mi->ctx;
+
+	(void)snprintf(mi->print, sizeof(mi->print), "%s [%s]",
+	    wm->name, wm->path);
 }

util.c

@@ -2,71 +2,139 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-#define MAXARGLEN 20
+static void	 log_msg(const char *, va_list);
 
-int
+void
 u_spawn(char *argstr)
 {
-	char *args[MAXARGLEN], **ap;
-	char **end = &args[MAXARGLEN - 1];
-
 	switch (fork()) {
 	case 0:
-		ap = args;
-		while (ap < end && (*ap = strsep(&argstr, " \t")) != NULL)
-			ap++;
-
-		*ap = NULL;
-		setsid();
-		execvp(args[0], args);
-		err(1, args[0]);
-		break;
+		u_exec(argstr);
+		exit(1);
 	case -1:
 		warn("fork");
-		return (-1);
 	default:
 		break;
 	}
-
-	return (0);
 }
 
-int dirent_exists(char *filename) {
-       struct stat buffer;
+void
+u_exec(char *argstr)
+{
+#define MAXARGLEN 20
+	char	*args[MAXARGLEN], **ap = args;
+	char	**end = &args[MAXARGLEN - 2], *tmp;
+	char	*s = argstr;
 
-       return stat(filename, &buffer);
+	while (ap < end && (*ap = strsep(&argstr, " \t")) != NULL) {
+		if (**ap == '\0')
+			continue;
+		ap++;
+		if (argstr != NULL) {
+			/* deal with quoted strings */
+			switch(argstr[0]) {
+			case '"':
+			case '\'':
+				if ((tmp = strchr(argstr + 1, argstr[0]))
+				    != NULL) {
+					*(tmp++) = '\0';
+					*(ap++) = ++argstr;
+					argstr = tmp;
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+	*ap = NULL;
+
+	(void)setsid();
+	(void)execvp(args[0], args);
+	warn("%s", s);
 }
 
-int dirent_isdir(char *filename) {
-       struct stat buffer;
-       int return_value;
+char *
+u_argv(char * const *argv)
+{
+	size_t	 siz = 0;
+	int	 i;
+	char	*p;
 
-       return_value = stat(filename, &buffer);
+	if (argv == 0)
+		return NULL;
 
-       if(return_value == -1)
-               return 0;
-       else
-               return S_ISDIR(buffer.st_mode);
+	for (i = 0; argv[i]; i++)
+		siz += strlen(argv[i]) + 1;
+	if (siz == 0)
+		return NULL;
+
+	p = xmalloc(siz);
+	strlcpy(p, argv[0], siz);
+	for (i = 1; argv[i]; i++) {
+		strlcat(p, " ", siz);
+		strlcat(p, argv[i], siz);
+	}
+	return p;
 }
 
-int dirent_islink(char *filename) {
-       struct stat buffer;
-       int return_value;
+static void
+log_msg(const char *msg, va_list ap)
+{
+	char	*fmt;
 
-       return_value = lstat(filename, &buffer);
-
-       if(return_value == -1)
-               return 0;
-       else
-               return S_ISLNK(buffer.st_mode);
+	if (asprintf(&fmt, "%s\n", msg) == -1) {
+		vfprintf(stderr, msg, ap);
+		fprintf(stderr, "\n");
+	} else {
+		vfprintf(stderr, fmt, ap);
+		free(fmt);
+	}
+	fflush(stderr);
 }
 
+void
+log_debug(int level, const char *func, const char *msg, ...)
+{
+	char	*fmt;
+	va_list	 ap;
 
+	if (Conf.debug < level)
+		return;
+
+	va_start(ap, msg);
+	xasprintf(&fmt, "debug%d: %s: %s", level, func, msg);
+	log_msg(fmt, ap);
+	free(fmt);
+	va_end(ap);
+}

xevents.c

@@ -2,9 +2,20 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
 /*
@@ -13,365 +24,294 @@
  *   management of the xevent's.
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-void _sendxmsg(Window, Atom, long);
+static void	 xev_handle_maprequest(XEvent *);
+static void	 xev_handle_unmapnotify(XEvent *);
+static void	 xev_handle_destroynotify(XEvent *);
+static void	 xev_handle_configurerequest(XEvent *);
+static void	 xev_handle_propertynotify(XEvent *);
+static void	 xev_handle_enternotify(XEvent *);
+static void	 xev_handle_buttonpress(XEvent *);
+static void	 xev_handle_buttonrelease(XEvent *);
+static void	 xev_handle_keypress(XEvent *);
+static void	 xev_handle_keyrelease(XEvent *);
+static void	 xev_handle_clientmessage(XEvent *);
+static void	 xev_handle_randr(XEvent *);
+static void	 xev_handle_mappingnotify(XEvent *);
+static void	 xev_handle_expose(XEvent *);
 
-/*
- * NOTE: in reality, many of these should move to client.c now that
- * we've got this nice event layer.
- */
+void		(*xev_handlers[LASTEvent])(XEvent *) = {
+			[MapRequest] = xev_handle_maprequest,
+			[UnmapNotify] = xev_handle_unmapnotify,
+			[DestroyNotify] = xev_handle_destroynotify,
+			[ConfigureRequest] = xev_handle_configurerequest,
+			[PropertyNotify] = xev_handle_propertynotify,
+			[EnterNotify] = xev_handle_enternotify,
+			[ButtonPress] = xev_handle_buttonpress,
+			[ButtonRelease] = xev_handle_buttonrelease,
+			[KeyPress] = xev_handle_keypress,
+			[KeyRelease] = xev_handle_keyrelease,
+			[ClientMessage] = xev_handle_clientmessage,
+			[MappingNotify] = xev_handle_mappingnotify,
+			[Expose] = xev_handle_expose,
+};
 
-void
-xev_handle_maprequest(struct xevent *xev, XEvent *ee)
+static KeySym modkeys[] = { XK_Alt_L, XK_Alt_R, XK_Super_L, XK_Super_R,
+			    XK_Control_L, XK_Control_R, XK_ISO_Level3_Shift };
+
+static void
+xev_handle_maprequest(XEvent *ee)
 {
-	XMapRequestEvent *e = &ee->xmaprequest;
-	struct client_ctx *cc = NULL, *old_cc = client_current();
-	XWindowAttributes xattr;
-	struct screen_ctx *sc;
-#ifdef notyet
-	int state;
-#endif
+	XMapRequestEvent	*e = &ee->xmaprequest;
+	struct screen_ctx	*sc;
+	struct client_ctx	*cc, *old_cc;
 
-	if (old_cc != NULL)
-		client_ptrsave(old_cc);
+	LOG_DEBUG3("parent: 0x%lx window: 0x%lx", e->parent, e->window);
 
-	if ((cc = client_find(e->window)) == NULL) { 
-		XGetWindowAttributes(X_Dpy, e->window, &xattr);
-		cc = client_new(e->window, screen_fromroot(xattr.root), 1);
-		sc = CCTOSC(cc);
-	} else {
-		cc->beepbeep = 1;
-	}
+	if ((sc = screen_find(e->parent)) == NULL)
+		return;
 
-#ifdef notyet			/* XXX - possibly, we shouldn't map if
-				 * the window is withdrawn. */
-	if (xu_getstate(cc, &state) == 0 && state == WithdrawnState)
-		warnx("WITHDRAWNSTATE for %s", cc->name);
-#endif
+	if ((old_cc = client_current(sc)) != NULL)
+		client_ptr_save(old_cc);
 
-	client_ptrwarp(cc);
-	xev_register(xev);
+	if ((cc = client_find(e->window)) == NULL)
+		cc = client_init(e->window, NULL);
+
+	if ((cc != NULL) && (!(cc->flags & CLIENT_IGNORE)))
+		client_ptr_warp(cc);
 }
 
-void
-xev_handle_unmapnotify(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_unmapnotify(XEvent *ee)
 {
-	XUnmapEvent *e = &ee->xunmap;
-	struct client_ctx *cc;
-	struct screen_ctx *sc;
-	int wascurrent;
+	XUnmapEvent		*e = &ee->xunmap;
+	struct client_ctx	*cc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
 
 	if ((cc = client_find(e->window)) != NULL) {
-		sc = CCTOSC(cc);
-		wascurrent = cc == client_current();
-		client_delete(cc, e->send_event, 0);
-
-#ifdef notyet
-		/* XXX disable the ptrwarp until we handle it
-		 * better. */
-		if (!client_delete(cc, e->send_event, 0) && wascurrent) 
-			;/* 			client_ptrwarp(new_cc); */
-#endif
+		if (e->send_event) {
+			xu_set_wm_state(cc->win, WithdrawnState);
+		} else {
+			if (!(cc->flags & CLIENT_HIDDEN))
+				client_remove(cc);
+		}
 	}
-
-	xev_register(xev);
 }
 
-void
-xev_handle_destroynotify(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_destroynotify(XEvent *ee)
 {
-	XDestroyWindowEvent *e = &ee->xdestroywindow;
-	struct client_ctx *cc;
+	XDestroyWindowEvent	*e = &ee->xdestroywindow;
+	struct client_ctx	*cc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
 
 	if ((cc = client_find(e->window)) != NULL)
-		client_delete(cc, 1, 1);
-
-	xev_register(xev);
+		client_remove(cc);
 }
 
-void
-xev_handle_configurerequest(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_configurerequest(XEvent *ee)
 {
-	XConfigureRequestEvent *e = &ee->xconfigurerequest;
-	struct client_ctx *cc;
-	struct screen_ctx *sc;
-	XWindowChanges wc;
+	XConfigureRequestEvent	*e = &ee->xconfigurerequest;
+	struct client_ctx	*cc;
+	struct screen_ctx	*sc;
+	XWindowChanges		 wc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
 
 	if ((cc = client_find(e->window)) != NULL) {
-		sc = CCTOSC(cc);
+		sc = cc->sc;
 
-		client_gravitate(cc, 0);
 		if (e->value_mask & CWWidth)
-			cc->geom.width = e->width;
+			cc->geom.w = e->width;
 		if (e->value_mask & CWHeight)
-			cc->geom.height = e->height;
+			cc->geom.h = e->height;
 		if (e->value_mask & CWX)
 			cc->geom.x = e->x;
 		if (e->value_mask & CWY)
 			cc->geom.y = e->y;
+		if (e->value_mask & CWBorderWidth)
+			cc->bwidth = e->border_width;
+		if (e->value_mask & CWSibling)
+			wc.sibling = e->above;
+		if (e->value_mask & CWStackMode)
+			wc.stack_mode = e->detail;
 
-                if (cc->geom.x == 0 &&
-		    cc->geom.width >= DisplayWidth(X_Dpy, sc->which))
+		if (cc->geom.x == 0 && cc->geom.w >= sc->view.w)
 			cc->geom.x -= cc->bwidth;
 
-                if (cc->geom.y == 0 &&
-		    cc->geom.height >= DisplayHeight(X_Dpy, sc->which))
-                        cc->geom.y -= cc->bwidth;
+		if (cc->geom.y == 0 && cc->geom.h >= sc->view.h)
+			cc->geom.y -= cc->bwidth;
 
-		client_gravitate(cc, 1);
+		wc.x = cc->geom.x;
+		wc.y = cc->geom.y;
+		wc.width = cc->geom.w;
+		wc.height = cc->geom.h;
+		wc.border_width = cc->bwidth;
 
-		wc.x = cc->geom.x - cc->bwidth;
-		wc.y = cc->geom.y - cc->bwidth;
-		wc.width = cc->geom.width + cc->bwidth*2;
-		wc.height = cc->geom.height + cc->bwidth*2;
-		wc.border_width = 0;
+		XConfigureWindow(X_Dpy, cc->win, e->value_mask, &wc);
+		client_config(cc);
+	} else {
+		/* let it do what it wants, it'll be ours when we map it. */
+		wc.x = e->x;
+		wc.y = e->y;
+		wc.width = e->width;
+		wc.height = e->height;
+		wc.border_width = e->border_width;
+		wc.stack_mode = Above;
+		e->value_mask &= ~CWStackMode;
 
-		/* We need to move the parent window, too. */
-		XConfigureWindow(X_Dpy, cc->pwin, e->value_mask, &wc);
-		xev_reconfig(cc);
+		XConfigureWindow(X_Dpy, e->window, e->value_mask, &wc);
 	}
-
-	wc.x = cc != NULL ? 0 : e->x;
-	wc.y = cc != NULL ? 0 : e->y;
-	wc.width = e->width;
-	wc.height = e->height;
-	wc.stack_mode = Above;
-	wc.border_width = 0;
-	e->value_mask &= ~CWStackMode;
-	e->value_mask |= CWBorderWidth;
-
-	XConfigureWindow(X_Dpy, e->window, e->value_mask, &wc);
-
-	xev_register(xev);
 }
 
-void
-xev_handle_propertynotify(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_propertynotify(XEvent *ee)
 {
-	XPropertyEvent *e = &ee->xproperty;
-	struct client_ctx *cc;
-	long tmp;
+	XPropertyEvent		*e = &ee->xproperty;
+	struct screen_ctx	*sc;
+	struct client_ctx	*cc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
 
 	if ((cc = client_find(e->window)) != NULL) {
-		switch(e->atom) { 
+		switch (e->atom) {
 		case XA_WM_NORMAL_HINTS:
-			XGetWMNormalHints(X_Dpy, cc->win, cc->size, &tmp);
+			client_get_sizehints(cc);
 			break;
 		case XA_WM_NAME:
-			client_setname(cc);
+			client_set_name(cc);
+			break;
+		case XA_WM_HINTS:
+			client_wm_hints(cc);
+			client_draw_border(cc);
+			break;
+		case XA_WM_TRANSIENT_FOR:
+			client_transient(cc);
+			client_draw_border(cc);
+			if (cc->gc)
+				group_movetogroup(cc, cc->gc->num);
 			break;
 		default:
-			/* do nothing */
+			if (e->atom == ewmh[_NET_WM_NAME])
+				client_set_name(cc);
 			break;
 		}
+	} else {
+		if (e->atom == ewmh[_NET_DESKTOP_NAMES])  {
+			if ((sc = screen_find(e->window)) != NULL)
+				xu_ewmh_net_desktop_names(sc);
+		}
 	}
-
-	xev_register(xev);
 }
 
-void
-xev_reconfig(struct client_ctx *cc)
+static void
+xev_handle_enternotify(XEvent *ee)
 {
-	XConfigureEvent ce;
+	XCrossingEvent		*e = &ee->xcrossing;
+	struct client_ctx	*cc;
 
-	ce.type = ConfigureNotify;
-	ce.event = cc->win;
-	ce.window = cc->win;
-	ce.x = cc->geom.x;
-	ce.y = cc->geom.y;
-	ce.width = cc->geom.width;
-	ce.height = cc->geom.height;
-	ce.border_width = 0;
-	ce.above = None;
-	ce.override_redirect = 0;
+	LOG_DEBUG3("window: 0x%lx", e->window);
 
-	XSendEvent(X_Dpy, cc->win, False, StructureNotifyMask, (XEvent *)&ce);
+	Last_Event_Time = e->time;
+
+	if ((cc = client_find(e->window)) != NULL)
+		client_set_active(cc);
 }
 
-void
-xev_handle_enternotify(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_buttonpress(XEvent *ee)
 {
-	XCrossingEvent *e = &ee->xcrossing;
-	struct client_ctx *cc;
+	XButtonEvent		*e = &ee->xbutton;
+	struct client_ctx	*cc;
+	struct screen_ctx	*sc;
+	struct bind_ctx		*mb;
 
-	if ((cc = client_find(e->window)) == NULL) {
-		/*
-		 * XXX - later.  messes up unclutter.  but may be
-		 * needed when we introduce menu windows and such into
-		 * the main event loop.
-		 */
-#ifdef notyet
-		if (e->window != e->root)
-			client_nocurrent();
-#endif
-	} else
-		client_setactive(cc, 1);
+	LOG_DEBUG3("root: 0x%lx window: 0x%lx subwindow: 0x%lx",
+	    e->root, e->window, e->subwindow);
 
-	xev_register(xev);
-}
+	if ((sc = screen_find(e->root)) == NULL)
+		return;
 
-void
-xev_handle_leavenotify(struct xevent *xev, XEvent *ee)
-{
-	client_leave(NULL);
+	e->state &= ~IGNOREMODMASK;
 
-	xev_register(xev);
-}
-
-/* We can split this into two event handlers. */
-void
-xev_handle_buttonpress(struct xevent *xev, XEvent *ee)
-{
-	XButtonEvent *e = &ee->xbutton;
-	struct client_ctx *cc, *old_cc = client_current();
-	struct screen_ctx *sc = screen_fromroot(e->root);
-	char *wname;
-	int altcontrol = e->state == (ControlMask|Mod1Mask);
-
-	cc = client_find(e->window);
-
-	if (sc->rootwin == e->window && !altcontrol) {
-		struct menu_q menuq;
-		struct menu *mi;
-
-		/* XXXSIGH!!!! */
-		if (e->button == Button2) {
-			group_menu(e);
-			goto out;
-		}
-
-		TAILQ_INIT(&menuq);
-
-		switch (e->button) {
-		case Button1:
-			TAILQ_FOREACH(cc, &Clientq, entry) {
-				if (cc->flags & CLIENT_HIDDEN) {
-					if (cc->label != NULL)
-						wname = cc->label;
-					else
-				  		wname = cc->name;
-
-					if (wname == NULL)
-						continue;
-
-					XCALLOC(mi, struct menu);
-					strlcpy(mi->text,
-					    wname, sizeof(mi->text));
-					mi->ctx = cc;
-					TAILQ_INSERT_TAIL(&menuq, mi, entry);
-				}
-			}
+	TAILQ_FOREACH(mb, &Conf.mousebindq, entry) {
+		if (e->button == mb->press.button && e->state == mb->modmask)
 			break;
-		case Button3: {
-			struct cmd *cmd;
-			if (conf_cmd_changed(Conf.menu_path)) {
-				conf_cmd_clear(&Conf);
-				conf_cmd_populate(&Conf, Conf.menu_path);
-			}
-			TAILQ_FOREACH(cmd, &Conf.cmdq, entry) {
-				XCALLOC(mi, struct menu);
-				strlcpy(mi->text, cmd->label, sizeof(mi->text));
-				mi->ctx = cmd;
-				TAILQ_INSERT_TAIL(&menuq, mi, entry);
-			}
-			break;
-		}
-		default:
-			break;
-		}
-
-		if (TAILQ_EMPTY(&menuq))
-			goto out;
-
-		mi = (struct menu *)grab_menu(e, &menuq);
-		if (mi == NULL)
-			goto cleanup;
-
-		switch (e->button) {
-		case Button1:
-			cc = (struct client_ctx *)mi->ctx;
-			client_unhide(cc);
-
-			if (old_cc != NULL)
-				client_ptrsave(old_cc);
-			client_ptrwarp(cc);
-			break;
-		case Button3:
-			u_spawn(((struct cmd *)mi->ctx)->image);
-			break;
-		default:
-			break;
-		}
-
-	cleanup:
-		while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
-			TAILQ_REMOVE(&menuq, mi, entry);
-			xfree(mi);
-		}
-
-		goto out;
 	}
-
-	if (cc == NULL || e->state == 0)
-		goto out;
-
-	sc = CCTOSC(cc);
-
-	switch (e->button) {
-	case Button1:
-		if (altcontrol && !Groupmode)
-			group_sticky_toggle_enter(cc);
-		else {
-			grab_drag(cc);
-			client_move(cc);
-		}
+	if (mb == NULL)
+		return;
+	mb->cargs->xev = CWM_XEV_BTN;
+	switch (mb->context) {
+	case CWM_CONTEXT_CC:
+		if (((cc = client_find(e->window)) == NULL) &&
+		    ((cc = client_current(sc)) == NULL))
+			return;
+		(*mb->callback)(cc, mb->cargs);
 		break;
-	case Button2:
-		/* XXXSIGH!!! */
-		if (Groupmode)
-			group_click(cc);
-		else {
-			grab_sweep(cc);
-			client_resize(cc);
-		}
+	case CWM_CONTEXT_SC:
+		(*mb->callback)(sc, mb->cargs);
 		break;
-	case Button3:
-		client_ptrsave(cc);
-		client_lower(cc);
+	case CWM_CONTEXT_NONE:
+		(*mb->callback)(NULL, mb->cargs);
 		break;
 	}
- out:
-	xev_register(xev);
 }
 
-void
-xev_handle_buttonrelease(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_buttonrelease(XEvent *ee)
 {
-	struct client_ctx *cc = client_current();
+	XButtonEvent		*e = &ee->xbutton;
+	struct client_ctx	*cc;
 
-	if (cc != NULL && !Groupmode)
-		group_sticky_toggle_exit(cc);
-
-	xev_register(xev);
+	LOG_DEBUG3("root: 0x%lx window: 0x%lx subwindow: 0x%lx",
+	    e->root, e->window, e->subwindow);
 
+	if ((cc = client_find(e->window)) != NULL) {
+		if (cc->flags & (CLIENT_ACTIVE | CLIENT_HIGHLIGHT)) {
+			cc->flags &= ~CLIENT_HIGHLIGHT;
+			client_draw_border(cc);
+		}
+	}
 }
 
-void
-xev_handle_keypress(struct xevent *xev, XEvent *ee)
+static void
+xev_handle_keypress(XEvent *ee)
 {
-	XKeyEvent *e = &ee->xkey;
-	struct client_ctx *cc = NULL; /* Make gcc happy. */
-	struct keybinding *kb;
-	KeySym keysym, skeysym;
-	int modshift;
+	XKeyEvent		*e = &ee->xkey;
+	struct client_ctx	*cc;
+	struct screen_ctx	*sc;
+	struct bind_ctx		*kb;
+	KeySym			 keysym, skeysym;
+	unsigned int		 modshift;
 
-	keysym = XKeycodeToKeysym(X_Dpy, e->keycode, 0);
-	skeysym = XKeycodeToKeysym(X_Dpy, e->keycode, 1);
-	
-        TAILQ_FOREACH(kb, &Conf.keybindingq, entry) {
-		if (keysym != kb->keysym && skeysym == kb->keysym)
+	LOG_DEBUG3("root: 0x%lx window: 0x%lx subwindow: 0x%lx",
+	    e->root, e->window, e->subwindow);
+
+	if ((sc = screen_find(e->root)) == NULL)
+		return;
+
+	keysym = XkbKeycodeToKeysym(X_Dpy, e->keycode, 0, 0);
+	skeysym = XkbKeycodeToKeysym(X_Dpy, e->keycode, 0, 1);
+
+	e->state &= ~IGNOREMODMASK;
+
+	TAILQ_FOREACH(kb, &Conf.keybindq, entry) {
+		if (keysym != kb->press.keysym && skeysym == kb->press.keysym)
 			modshift = ShiftMask;
 		else
 			modshift = 0;
@@ -379,225 +319,175 @@ xev_handle_keypress(struct xevent *xev, XEvent *ee)
 		if ((kb->modmask | modshift) != e->state)
 			continue;
 
-		if ((kb->keycode != 0 && kb->keysym == NoSymbol &&
-			kb->keycode == e->keycode) || kb->keysym ==
-			(modshift == 0 ? keysym : skeysym))
+		if (kb->press.keysym == ((modshift == 0) ? keysym : skeysym))
 			break;
-        }
-
-	if (kb == NULL && e->window == screen_current()->groupwin)
-		group_display_keypress(e->keycode);
-
+	}
 	if (kb == NULL)
-		goto out;
-
-	if ((kb->flags & (KBFLAG_NEEDCLIENT|KBFLAG_FINDCLIENT)) && 
-	    (cc = client_find(e->window)) == NULL &&
-	    (cc = client_current()) == NULL)
-		if (kb->flags & KBFLAG_NEEDCLIENT)
-			goto out;
-
-	(*kb->callback)(cc, kb->argument);
-
-out:
-	xev_register(xev);
-}
-
-/*
- * This is only used for the alt supression detection.
- */
-void
-xev_handle_keyrelease(struct xevent *xev, XEvent *ee)
-{
-	XKeyEvent *e = &ee->xkey;
-	struct screen_ctx *sc = screen_fromroot(e->root);
-	int keysym;
-
-	keysym = XKeycodeToKeysym(X_Dpy, e->keycode, 0);
-	if (keysym != XK_Alt_L && keysym != XK_Alt_R)
-		goto out;
-
-	sc->altpersist = 0;
-	
-	/*
-	 * XXX - better interface... xevents should not know about
-	 * how/when to mtf.
-	 */
-	client_mtf(NULL);
-	client_altrelease();
-
- out:
-	xev_register(xev);
-}
-
-void
-xev_handle_clientmessage(struct xevent *xev, XEvent *ee)
-{
-	XClientMessageEvent *e = &ee->xclient;
-	struct client_ctx *cc = client_find(e->window);
-	Atom xa_wm_change_state = XInternAtom(X_Dpy, "WM_CHANGE_STATE", False);
-
-	if (cc == NULL)
-		goto out;
-
-	if (e->message_type == xa_wm_change_state && e->format == 32 &&
-	    e->data.l[0] == IconicState)
-		client_hide(cc);
-out:
-	xev_register(xev);
-}
-
-/*
- * X Event handling
- */
-
-static struct xevent_q _xevq, _xevq_putaway;
-static short _xev_q_lock = 0;
-
-void
-xev_init(void)
-{
-	TAILQ_INIT(&_xevq);
-	TAILQ_INIT(&_xevq_putaway);
-}
-
-struct xevent *
-xev_new(Window *win, Window *root,
-    int type, void (*cb)(struct xevent *, XEvent *), void *arg)
-{
-	struct xevent *xev;
-
-	XMALLOC(xev, struct xevent);
-	xev->xev_win = win;
-	xev->xev_root = root;
-	xev->xev_type = type;
-	xev->xev_cb = cb;
-	xev->xev_arg = arg;
-
-	return (xev);
-}
-
-void
-xev_register(struct xevent *xev)
-{
-	struct xevent_q *xq;
-
-	xq = _xev_q_lock ? &_xevq_putaway : &_xevq;
-	TAILQ_INSERT_TAIL(xq, xev, entry);
-}
-
-void
-_xev_reincorporate(void)
-{
-	struct xevent *xev;
-
-	while ((xev = TAILQ_FIRST(&_xevq_putaway)) != NULL) {
-		TAILQ_REMOVE(&_xevq_putaway, xev, entry);
-		TAILQ_INSERT_TAIL(&_xevq, xev, entry);
+		return;
+	kb->cargs->xev = CWM_XEV_KEY;
+	switch (kb->context) {
+	case CWM_CONTEXT_CC:
+		if (((cc = client_find(e->subwindow)) == NULL) &&
+		    ((cc = client_current(sc)) == NULL))
+			return;
+		(*kb->callback)(cc, kb->cargs);
+		break;
+	case CWM_CONTEXT_SC:
+		(*kb->callback)(sc, kb->cargs);
+		break;
+	case CWM_CONTEXT_NONE:
+		(*kb->callback)(NULL, kb->cargs);
+		break;
 	}
 }
 
-void
-xev_handle_expose(struct xevent *xev, XEvent *ee)
+/*
+ * This is only used for the modifier suppression detection.
+ */
+static void
+xev_handle_keyrelease(XEvent *ee)
 {
-	XExposeEvent *e = &ee->xexpose;
-	struct screen_ctx *sc = screen_current();
-	struct client_ctx *cc;
+	XKeyEvent		*e = &ee->xkey;
+	struct screen_ctx	*sc;
+	struct client_ctx	*cc;
+	KeySym			 keysym;
+	unsigned int		 i;
 
-	if ((cc = client_find(e->window)) != NULL)
+	LOG_DEBUG3("root: 0x%lx window: 0x%lx subwindow: 0x%lx",
+	    e->root, e->window, e->subwindow);
+
+	if ((sc = screen_find(e->root)) == NULL)
+		return;
+
+	keysym = XkbKeycodeToKeysym(X_Dpy, e->keycode, 0, 0);
+	for (i = 0; i < nitems(modkeys); i++) {
+		if (keysym == modkeys[i]) {
+			if ((cc = client_current(sc)) != NULL) {
+				if (sc->cycling) {
+					sc->cycling = 0;
+					client_mtf(cc);
+				}
+				if (cc->flags & CLIENT_HIGHLIGHT) {
+					cc->flags &= ~CLIENT_HIGHLIGHT;
+					client_draw_border(cc);
+				}
+			}
+			XUngrabKeyboard(X_Dpy, CurrentTime);
+			break;
+		}
+	}
+}
+
+static void
+xev_handle_clientmessage(XEvent *ee)
+{
+	XClientMessageEvent	*e = &ee->xclient;
+	struct client_ctx	*cc, *old_cc;
+	struct screen_ctx       *sc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
+
+	if (e->message_type == cwmh[WM_CHANGE_STATE]) {
+		if ((cc = client_find(e->window)) != NULL) {
+	    		if (e->data.l[0] == IconicState)
+				client_hide(cc);
+		}
+	} else if (e->message_type == ewmh[_NET_CLOSE_WINDOW]) {
+		if ((cc = client_find(e->window)) != NULL) {
+			client_close(cc);
+		}
+	} else if (e->message_type == ewmh[_NET_ACTIVE_WINDOW]) {
+		if ((cc = client_find(e->window)) != NULL) {
+			if ((old_cc = client_current(NULL)) != NULL)
+				client_ptr_save(old_cc);
+			client_show(cc);
+			client_ptr_warp(cc);
+		}
+	} else if (e->message_type == ewmh[_NET_WM_DESKTOP]) {
+		if ((cc = client_find(e->window)) != NULL) {
+			/*
+			 * The EWMH spec states that if the cardinal returned
+			 * is 0xFFFFFFFF (-1) then the window should appear
+			 * on all desktops, in our case, group 0.
+			 */
+			if (e->data.l[0] == (unsigned long)-1)
+				group_movetogroup(cc, 0);
+			else
+				if (e->data.l[0] >= 0 &&
+				    e->data.l[0] < Conf.ngroups)
+					group_movetogroup(cc, e->data.l[0]);
+		}
+	} else if (e->message_type == ewmh[_NET_WM_STATE]) {
+		if ((cc = client_find(e->window)) != NULL) {
+			xu_ewmh_handle_net_wm_state_msg(cc,
+			    e->data.l[0], e->data.l[1], e->data.l[2]);
+		}
+	} else if (e->message_type == ewmh[_NET_CURRENT_DESKTOP]) {
+		if ((sc = screen_find(e->window)) != NULL) {
+			if (e->data.l[0] >= 0 &&
+			    e->data.l[0] < Conf.ngroups)
+				group_only(sc, e->data.l[0]);
+		}
+	}
+}
+
+static void
+xev_handle_randr(XEvent *ee)
+{
+	XRRScreenChangeNotifyEvent	*e = (XRRScreenChangeNotifyEvent *)ee;
+	struct screen_ctx		*sc;
+
+	LOG_DEBUG3("size: %d/%d", e->width, e->height);
+
+	if ((sc = screen_find(e->root)) == NULL)
+		return;
+
+	XRRUpdateConfiguration(ee);
+	screen_update_geometry(sc);
+	screen_assert_clients_within(sc);
+}
+
+/*
+ * Called when the keymap has changed.
+ * Ungrab all keys, reload keymap and then regrab
+ */
+static void
+xev_handle_mappingnotify(XEvent *ee)
+{
+	XMappingEvent		*e = &ee->xmapping;
+	struct screen_ctx	*sc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
+
+	XRefreshKeyboardMapping(e);
+	if (e->request == MappingKeyboard) {
+		TAILQ_FOREACH(sc, &Screenq, entry)
+			conf_grab_kbd(sc->rootwin);
+	}
+}
+
+static void
+xev_handle_expose(XEvent *ee)
+{
+	XExposeEvent		*e = &ee->xexpose;
+	struct client_ctx	*cc;
+
+	LOG_DEBUG3("window: 0x%lx", e->window);
+
+	if ((cc = client_find(e->window)) != NULL && e->count == 0)
 		client_draw_border(cc);
-
-	if (sc->groupwin == e->window)
-		group_display_draw(sc);
-
-	xev_register(xev);
 }
 
-#define ASSIGN(xtype) do {			\
-	root = e. xtype .root;			\
-	win = e. xtype .window;			\
-} while (0)
-
-#define ASSIGN1(xtype) do {			\
-	win = e. xtype .window;			\
-} while (0)
-
 void
-xev_loop(void)
+xev_process(void)
 {
-	Window win, root;
-	int type;
-	XEvent e;
-	struct xevent *xev, *nextxev;
-
-	for (;;) {
-#ifdef DIAGNOSTIC
-		if (TAILQ_EMPTY(&_xevq))
-			errx(1, "X event queue empty");
-#endif		
+	XEvent		 e;
 
+	while (XPending(X_Dpy)) {
 		XNextEvent(X_Dpy, &e);
-		type = e.type;
-
-		win = root = 0;
-
-		switch (type) {
-		case MapRequest:
-			ASSIGN1(xmaprequest);
-			break;
-		case UnmapNotify:
-			ASSIGN1(xunmap);
-			break;
-		case ConfigureRequest:
-			ASSIGN1(xconfigurerequest);
-			break;
-		case PropertyNotify:
-			ASSIGN1(xproperty);
-			break;
-		case EnterNotify:
-		case LeaveNotify:
-			ASSIGN(xcrossing);
-			break;
-		case ButtonPress:
-			ASSIGN(xbutton);
-			break;
-		case ButtonRelease:
-			ASSIGN(xbutton);
-			break;
-		case KeyPress:
-		case KeyRelease:
-			ASSIGN(xkey);
-			break;
-		case DestroyNotify:
-			ASSIGN1(xdestroywindow);
-			break;
-		case ClientMessage:
-			ASSIGN1(xclient);
-			break;
-		default:	/* XXX - still need shape event support. */
-			break;
-		}
-
-		/*
-		 * Now, search for matches, and call each of them.
-		 */
-		_xev_q_lock = 1;
-		for (xev = TAILQ_FIRST(&_xevq); xev != NULL; xev = nextxev) {
-			nextxev = TAILQ_NEXT(xev, entry);
-
-			if ((type != xev->xev_type && xev->xev_type != 0) ||
-			    (xev->xev_win != NULL && win != *xev->xev_win) ||
-			    (xev->xev_root != NULL && root != *xev->xev_root))
-				continue;
-
-			TAILQ_REMOVE(&_xevq, xev, entry);
-
-			(*xev->xev_cb)(xev, &e);
-		}
-		_xev_q_lock = 0;
-		_xev_reincorporate();
+		if ((e.type - Conf.xrandr_event_base) == RRScreenChangeNotify)
+			xev_handle_randr(&e);
+		else if ((e.type < LASTEvent) && (xev_handlers[e.type] != NULL))
+			(*xev_handlers[e.type])(&e);
 	}
 }
-
-#undef ASSIGN
-#undef ASSIGN1

xmalloc.c

@@ -2,49 +2,109 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
 void *
 xmalloc(size_t siz)
 {
-	void *p;
+	void	*p;
 
+	if (siz == 0)
+		errx(1, "xmalloc: zero size");
 	if ((p = malloc(siz)) == NULL)
 		err(1, "malloc");
 
-	return (p);
+	return p;
 }
 
 void *
-xcalloc(size_t siz)
+xcalloc(size_t no, size_t siz)
 {
-	void *p;
+	void	*p;
 
-	if ((p = calloc(1, siz)) == NULL)
+	if (siz == 0 || no == 0)
+		errx(1, "xcalloc: zero size");
+	if (SIZE_MAX / no < siz)
+		errx(1, "xcalloc: no * siz > SIZE_MAX");
+	if ((p = calloc(no, siz)) == NULL)
 		err(1, "calloc");
 
-	return (p);
+	return p;
 }
 
-void
-xfree(void *p)
+void *
+xreallocarray(void *ptr, size_t nmemb, size_t size)
 {
-	free(p);
+	void	*p;
+
+	p = reallocarray(ptr, nmemb, size);
+	if (p == NULL)
+		errx(1, "xreallocarray: out of memory (new_size %zu bytes)",
+		    nmemb * size);
+	return p;
 }
 
 char *
 xstrdup(const char *str)
 {
-	char *p;
+	char	*p;
 
 	if ((p = strdup(str)) == NULL)
 		err(1, "strdup");
 
-	return (p);
+	return p;
+}
+
+int
+xasprintf(char **ret, const char *fmt, ...)
+{
+	va_list	 ap;
+	int	 i;
+
+	va_start(ap, fmt);
+	i = xvasprintf(ret, fmt, ap);
+	va_end(ap);
+
+	return i;
+}
+
+int
+xvasprintf(char **ret, const char *fmt, va_list ap)
+{
+	int	 i;
+
+	i = vasprintf(ret, fmt, ap);
+	if (i == -1)
+		err(1, "vasprintf");
+
+	return i;
 }

xutil.c

@@ -2,161 +2,567 @@
  * calmwm - the calm window manager
  *
  * Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
- * All rights reserved.
  *
- * $Id$
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * $OpenBSD$
  */
 
-#include "headers.h"
+#include <sys/types.h>
+#include <sys/queue.h>
+
+#include <err.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
 #include "calmwm.h"
 
-int
-xu_ptr_grab(Window win, int mask, Cursor curs)
+void
+xu_ptr_get(Window win, int *x, int *y)
 {
-	return (XGrabPointer(X_Dpy, win, False, mask,
-		    GrabModeAsync, GrabModeAsync,
-		    None, curs, CurrentTime) == GrabSuccess ? 0 : -1);
-}
+	Window		 w0, w1;
+	int		 tmp0, tmp1;
+	unsigned int	 tmp2;
 
-int
-xu_ptr_regrab(int mask, Cursor curs)
-{
-	return (XChangeActivePointerGrab(X_Dpy, mask,
-		curs, CurrentTime) == GrabSuccess ? 0 : -1);
+	XQueryPointer(X_Dpy, win, &w0, &w1, &tmp0, &tmp1, x, y, &tmp2);
 }
 
 void
-xu_ptr_ungrab(void)
-{
-	XUngrabPointer(X_Dpy, CurrentTime);
-}
-
-int
-xu_btn_grab(Window win, int mask, u_int btn)
-{
-        return (XGrabButton(X_Dpy, btn, mask, win,
-		    False, ButtonMask, GrabModeAsync,
-		    GrabModeSync, None, None) == GrabSuccess ? 0 : -1);
-}
-
-void
-xu_btn_ungrab(Window win, int mask, u_int btn)
-{
-	XUngrabButton(X_Dpy, btn, mask, win);
-}
-
-void
-xu_ptr_getpos(Window rootwin, int *x, int *y)
-{
-	int tmp0, tmp1;
-	u_int tmp2;
-	Window w0, w1;
-
-        XQueryPointer(X_Dpy, rootwin, &w0, &w1, &tmp0, &tmp1, x, y, &tmp2);
-}
-
-void
-xu_ptr_setpos(Window win, int x, int y)
+xu_ptr_set(Window win, int x, int y)
 {
 	XWarpPointer(X_Dpy, None, win, 0, 0, 0, 0, x, y);
 }
 
-void
-xu_key_grab(Window win, int mask, int keysym)
-{
-	KeyCode code;
-
-	code = XKeysymToKeycode(X_Dpy, keysym);
-	if ((XKeycodeToKeysym(X_Dpy, code, 0) != keysym) &&
-	    (XKeycodeToKeysym(X_Dpy, code, 1) == keysym))
-		mask |= ShiftMask;
-
-        XGrabKey(X_Dpy, XKeysymToKeycode(X_Dpy, keysym), mask, win, True,
-	    GrabModeAsync, GrabModeAsync);
-#if 0
-        XGrabKey(X_Dpy, XKeysymToKeycode(X_Dpy, keysym), LockMask|mask,
-	    win, True, GrabModeAsync, GrabModeAsync);
-#endif
-}
-
-void
-xu_key_grab_keycode(Window win, int mask, int keycode)
-{
-        XGrabKey(X_Dpy, keycode, mask, win, True, GrabModeAsync, GrabModeAsync);
-}
-
-void
-xu_sendmsg(struct client_ctx *cc, Atom atm, long val)
-{
-	XEvent e;
-
-	memset(&e, 0, sizeof(e));
-	e.xclient.type = ClientMessage;
-	e.xclient.window = cc->win;
-	e.xclient.message_type = atm;
-	e.xclient.format = 32;
-	e.xclient.data.l[0] = val;
-	e.xclient.data.l[1] = CurrentTime;
-
-	XSendEvent(X_Dpy, cc->win, False, 0, &e);
-}
-
 int
-xu_getprop(struct client_ctx *cc, Atom atm, Atom type, long len, u_char **p)
+xu_get_prop(Window win, Atom atm, Atom type, long len, unsigned char **p)
 {
-	Atom realtype;
-	u_long n, extra;
-	int format;
+	Atom		 realtype;
+	unsigned long	 n, extra;
+	int		 format;
 
-	if (XGetWindowProperty(X_Dpy, cc->win, atm, 0L, len, False, type,
-		&realtype, &format, &n, &extra, p) != Success || *p == NULL)
-		return (-1);
+	if (XGetWindowProperty(X_Dpy, win, atm, 0L, len, False, type,
+	    &realtype, &format, &n, &extra, p) != Success || *p == NULL)
+		return -1;
 
 	if (n == 0)
 		XFree(*p);
 
-	return (n);
+	return n;
 }
 
 int
-xu_getstate(struct client_ctx *cc, int *state)
-{
-	Atom wm_state = XInternAtom(X_Dpy, "WM_STATE", False);
-	long *p = NULL;
+xu_get_strprop(Window win, Atom atm, char **text) {
+	XTextProperty	 prop;
+	char		**list;
+	int		 nitems = 0;
 
-	if (xu_getprop(cc, wm_state, wm_state, 2L, (u_char **)&p) <= 0)
-		return (-1);
+	*text = NULL;
 
-	*state = (int)*p;
-	XFree((char *)p);
+	XGetTextProperty(X_Dpy, win, &prop, atm);
+	if (!prop.nitems) {
+		XFree(prop.value);
+		return 0;
+	}
 
-	return (0);
-}
+	if (Xutf8TextPropertyToTextList(X_Dpy, &prop, &list,
+	    &nitems) == Success && nitems > 0 && *list) {
+		if (nitems > 1) {
+			XTextProperty    prop2;
+			if (Xutf8TextListToTextProperty(X_Dpy, list, nitems,
+			    XUTF8StringStyle, &prop2) == Success) {
+				*text = xstrdup((const char *)prop2.value);
+				XFree(prop2.value);
+			}
+		} else {
+			*text = xstrdup(*list);
+		}
+		XFreeStringList(list);
+	}
+	XFree(prop.value);
 
-char *
-xu_getstrprop(struct client_ctx *cc, Atom atm)
-{
-	u_char *cp;
-
-	if (xu_getprop(cc, atm, XA_STRING, 100L, &cp) <= 0)
-		return (NULL);
-
-	return ((char *)cp);
+	return nitems;
 }
 
 void
-xu_setstate(struct client_ctx *cc, int state)
+xu_send_clientmsg(Window win, Atom proto, Time ts)
 {
-	long dat[2];
-	Atom wm_state;
+	XClientMessageEvent	 cm;
 
-	/* XXX cache */
-	wm_state = XInternAtom(X_Dpy, "WM_STATE", False);
+	(void)memset(&cm, 0, sizeof(cm));
+	cm.type = ClientMessage;
+	cm.window = win;
+	cm.message_type = cwmh[WM_PROTOCOLS];
+	cm.format = 32;
+	cm.data.l[0] = proto;
+	cm.data.l[1] = ts;
 
-	dat[0] = (long)state;
-	dat[1] = (long)None;
-
-	cc->state = state;
-	XChangeProperty(X_Dpy, cc->win, wm_state, wm_state, 32,
-	    PropModeReplace, (unsigned char *)dat, 2);
+	XSendEvent(X_Dpy, win, False, NoEventMask, (XEvent *)&cm);
+}
+
+void
+xu_get_wm_state(Window win, long *state)
+{
+	long	*p;
+
+	*state = -1;
+	if (xu_get_prop(win, cwmh[WM_STATE], cwmh[WM_STATE], 2L,
+	    (unsigned char **)&p) > 0) {
+		*state = *p;
+		XFree(p);
+	}
+}
+
+void
+xu_set_wm_state(Window win, long state)
+{
+	long	 data[] = { state, None };
+
+	XChangeProperty(X_Dpy, win, cwmh[WM_STATE], cwmh[WM_STATE], 32,
+	    PropModeReplace, (unsigned char *)data, 2);
+}
+void
+xu_xorcolor(XftColor a, XftColor b, XftColor *r)
+{
+	r->pixel = a.pixel ^ b.pixel;
+	r->color.red = a.color.red ^ b.color.red;
+	r->color.green = a.color.green ^ b.color.green;
+	r->color.blue = a.color.blue ^ b.color.blue;
+	r->color.alpha = 0xffff;
+}
+
+void
+xu_atom_init(void)
+{
+	char *cwmhints[] = {
+		"WM_STATE",
+		"WM_DELETE_WINDOW",
+		"WM_TAKE_FOCUS",
+		"WM_PROTOCOLS",
+		"_MOTIF_WM_HINTS",
+		"UTF8_STRING",
+		"WM_CHANGE_STATE",
+	};
+	char *ewmhints[] = {
+		"_NET_SUPPORTED",
+		"_NET_SUPPORTING_WM_CHECK",
+		"_NET_ACTIVE_WINDOW",
+		"_NET_CLIENT_LIST",
+		"_NET_CLIENT_LIST_STACKING",
+		"_NET_NUMBER_OF_DESKTOPS",
+		"_NET_CURRENT_DESKTOP",
+		"_NET_DESKTOP_VIEWPORT",
+		"_NET_DESKTOP_GEOMETRY",
+		"_NET_VIRTUAL_ROOTS",
+		"_NET_SHOWING_DESKTOP",
+		"_NET_DESKTOP_NAMES",
+		"_NET_WORKAREA",
+		"_NET_WM_NAME",
+		"_NET_WM_DESKTOP",
+		"_NET_CLOSE_WINDOW",
+		"_NET_WM_STATE",
+		"_NET_WM_STATE_STICKY",
+		"_NET_WM_STATE_MAXIMIZED_VERT",
+		"_NET_WM_STATE_MAXIMIZED_HORZ",
+		"_NET_WM_STATE_HIDDEN",
+		"_NET_WM_STATE_FULLSCREEN",
+		"_NET_WM_STATE_DEMANDS_ATTENTION",
+		"_NET_WM_STATE_SKIP_PAGER",
+		"_NET_WM_STATE_SKIP_TASKBAR",
+		"_CWM_WM_STATE_FREEZE",
+	};
+
+	XInternAtoms(X_Dpy, cwmhints, nitems(cwmhints), False, cwmh);
+	XInternAtoms(X_Dpy, ewmhints, nitems(ewmhints), False, ewmh);
+}
+
+/* Root Window Properties */
+void
+xu_ewmh_net_supported(struct screen_ctx *sc)
+{
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_SUPPORTED],
+	    XA_ATOM, 32, PropModeReplace, (unsigned char *)ewmh, EWMH_NITEMS);
+}
+
+void
+xu_ewmh_net_supported_wm_check(struct screen_ctx *sc)
+{
+	Window	 w;
+
+	w = XCreateSimpleWindow(X_Dpy, sc->rootwin, -1, -1, 1, 1, 0, 0, 0);
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_SUPPORTING_WM_CHECK],
+	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)&w, 1);
+	XChangeProperty(X_Dpy, w, ewmh[_NET_SUPPORTING_WM_CHECK],
+	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)&w, 1);
+	XChangeProperty(X_Dpy, w, ewmh[_NET_WM_NAME],
+	    cwmh[UTF8_STRING], 8, PropModeReplace,
+	    (unsigned char *)Conf.wmname, strlen(Conf.wmname));
+}
+
+void
+xu_ewmh_net_desktop_geometry(struct screen_ctx *sc)
+{
+	long	 geom[2] = { sc->view.w, sc->view.h };
+
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_DESKTOP_GEOMETRY],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)geom , 2);
+}
+
+void
+xu_ewmh_net_desktop_viewport(struct screen_ctx *sc)
+{
+	long	 viewports[2] = {0, 0};
+
+	/* We don't support large desktops, so this is (0, 0). */
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_DESKTOP_VIEWPORT],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)viewports, 2);
+}
+
+void
+xu_ewmh_net_workarea(struct screen_ctx *sc)
+{
+	unsigned long	*workarea;
+	int		 i, ngroups = Conf.ngroups;
+
+	workarea = xreallocarray(NULL, ngroups * 4, sizeof(unsigned long));
+	for (i = 0; i < ngroups; i++) {
+		workarea[4 * i + 0] = sc->work.x;
+		workarea[4 * i + 1] = sc->work.y;
+		workarea[4 * i + 2] = sc->work.w;
+		workarea[4 * i + 3] = sc->work.h;
+	}
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_WORKAREA],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)workarea,
+	    ngroups * 4);
+	free(workarea);
+}
+
+void
+xu_ewmh_net_client_list(struct screen_ctx *sc)
+{
+	struct client_ctx	*cc;
+	Window			*winlist;
+	int			 i = 0, j = 0;
+
+	TAILQ_FOREACH(cc, &sc->clientq, entry)
+		i++;
+	if (i == 0)
+		return;
+
+	winlist = xreallocarray(NULL, i, sizeof(*winlist));
+	TAILQ_FOREACH(cc, &sc->clientq, entry)
+		winlist[j++] = cc->win;
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_CLIENT_LIST],
+	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)winlist, i);
+	free(winlist);
+}
+
+void
+xu_ewmh_net_client_list_stacking(struct screen_ctx *sc)
+{
+	struct client_ctx	*cc;
+	Window			*winlist;
+	int			 i = 0, j;
+
+	TAILQ_FOREACH(cc, &sc->clientq, entry)
+		i++;
+	if (i == 0)
+		return;
+
+	j = i;
+	winlist = xreallocarray(NULL, i, sizeof(*winlist));
+	TAILQ_FOREACH(cc, &sc->clientq, entry)
+		winlist[--j] = cc->win;
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_CLIENT_LIST_STACKING],
+	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)winlist, i);
+	free(winlist);
+}
+
+void
+xu_ewmh_net_active_window(struct screen_ctx *sc, Window w)
+{
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_ACTIVE_WINDOW],
+	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)&w, 1);
+}
+
+void
+xu_ewmh_net_number_of_desktops(struct screen_ctx *sc)
+{
+	long	 ndesks = Conf.ngroups;
+
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_NUMBER_OF_DESKTOPS],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&ndesks, 1);
+}
+
+void
+xu_ewmh_net_showing_desktop(struct screen_ctx *sc)
+{
+	long	 zero = 0;
+
+	/* We don't support `showing desktop' mode, so this is zero.
+	 * Note that when we hide all groups, or when all groups are
+	 * hidden we could technically set this later on.
+	 */
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_SHOWING_DESKTOP],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&zero, 1);
+}
+
+void
+xu_ewmh_net_virtual_roots(struct screen_ctx *sc)
+{
+	/* We don't support virtual roots, so delete if set by previous wm. */
+	XDeleteProperty(X_Dpy, sc->rootwin, ewmh[_NET_VIRTUAL_ROOTS]);
+}
+
+void
+xu_ewmh_net_current_desktop(struct screen_ctx *sc)
+{
+	long	 num = sc->group_active->num;
+
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_CURRENT_DESKTOP],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&num, 1);
+}
+
+void
+xu_ewmh_net_desktop_names(struct screen_ctx *sc)
+{
+	struct group_ctx	*gc;
+	char			*p, *q;
+	unsigned char		*prop_ret;
+	int			 i = 0, j = 0, nstrings = 0, n = 0;
+	size_t			 len = 0, tlen, slen;
+
+	/* Let group names be overwritten if _NET_DESKTOP_NAMES is set. */
+
+	if ((j = xu_get_prop(sc->rootwin, ewmh[_NET_DESKTOP_NAMES],
+	    cwmh[UTF8_STRING], 0xffffff, (unsigned char **)&prop_ret)) > 0) {
+		prop_ret[j - 1] = '\0'; /* paranoia */
+		while (i < j) {
+			if (prop_ret[i++] == '\0')
+				nstrings++;
+		}
+	}
+
+	p = (char *)prop_ret;
+	while (n < nstrings) {
+		TAILQ_FOREACH(gc, &sc->groupq, entry) {
+			if (gc->num == n) {
+				free(gc->name);
+				gc->name = xstrdup(p);
+				p += strlen(p) + 1;
+				break;
+			}
+		}
+		n++;
+	}
+	if (prop_ret != NULL)
+		XFree(prop_ret);
+
+	TAILQ_FOREACH(gc, &sc->groupq, entry)
+		len += strlen(gc->name) + 1;
+	q = p = xreallocarray(NULL, len, sizeof(*p));
+
+	tlen = len;
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		slen = strlen(gc->name) + 1;
+		(void)strlcpy(q, gc->name, tlen);
+		tlen -= slen;
+		q += slen;
+	}
+
+	XChangeProperty(X_Dpy, sc->rootwin, ewmh[_NET_DESKTOP_NAMES],
+	    cwmh[UTF8_STRING], 8, PropModeReplace, (unsigned char *)p, len);
+	free(p);
+}
+
+/* Application Window Properties */
+int
+xu_ewmh_get_net_wm_desktop(struct client_ctx *cc, long *n)
+{
+	long		*p;
+
+	if (xu_get_prop(cc->win, ewmh[_NET_WM_DESKTOP], XA_CARDINAL, 1L,
+	    (unsigned char **)&p) <= 0)
+		return 0;
+	*n = *p;
+	XFree(p);
+	return 1;
+}
+
+void
+xu_ewmh_set_net_wm_desktop(struct client_ctx *cc)
+{
+	long	 num = 0xffffffff;
+
+	if (cc->gc)
+		num = cc->gc->num;
+
+	XChangeProperty(X_Dpy, cc->win, ewmh[_NET_WM_DESKTOP],
+	    XA_CARDINAL, 32, PropModeReplace, (unsigned char *)&num, 1);
+}
+
+Atom *
+xu_ewmh_get_net_wm_state(struct client_ctx *cc, int *n)
+{
+	Atom	*state, *p = NULL;
+
+	if ((*n = xu_get_prop(cc->win, ewmh[_NET_WM_STATE], XA_ATOM, 64L,
+	    (unsigned char **)&p)) <= 0)
+		return NULL;
+
+	state = xreallocarray(NULL, *n, sizeof(Atom));
+	(void)memcpy(state, p, *n * sizeof(Atom));
+	XFree((char *)p);
+
+	return state;
+}
+
+void
+xu_ewmh_handle_net_wm_state_msg(struct client_ctx *cc, int action,
+    Atom first, Atom second)
+{
+	unsigned int i;
+	struct handlers {
+		Atom atom;
+		int flag;
+		void (*toggle)(struct client_ctx *);
+	} handlers[] = {
+		{ _NET_WM_STATE_STICKY,
+			CLIENT_STICKY,
+			client_toggle_sticky },
+		{ _NET_WM_STATE_MAXIMIZED_VERT,
+			CLIENT_VMAXIMIZED,
+			client_toggle_vmaximize },
+		{ _NET_WM_STATE_MAXIMIZED_HORZ,
+			CLIENT_HMAXIMIZED,
+			client_toggle_hmaximize },
+		{ _NET_WM_STATE_HIDDEN,
+			CLIENT_HIDDEN,
+			client_toggle_hidden },
+		{ _NET_WM_STATE_FULLSCREEN,
+			CLIENT_FULLSCREEN,
+			client_toggle_fullscreen },
+		{ _NET_WM_STATE_DEMANDS_ATTENTION,
+			CLIENT_URGENCY,
+			client_urgency },
+		{ _NET_WM_STATE_SKIP_PAGER,
+			CLIENT_SKIP_PAGER,
+			client_toggle_skip_pager},
+		{ _NET_WM_STATE_SKIP_TASKBAR,
+			CLIENT_SKIP_TASKBAR,
+			client_toggle_skip_taskbar},
+		{ _CWM_WM_STATE_FREEZE,
+			CLIENT_FREEZE,
+			client_toggle_freeze },
+	};
+
+	for (i = 0; i < nitems(handlers); i++) {
+		if (first != ewmh[handlers[i].atom] &&
+		    second != ewmh[handlers[i].atom])
+			continue;
+		switch (action) {
+		case _NET_WM_STATE_ADD:
+			if (!(cc->flags & handlers[i].flag))
+				handlers[i].toggle(cc);
+			break;
+		case _NET_WM_STATE_REMOVE:
+			if (cc->flags & handlers[i].flag)
+				handlers[i].toggle(cc);
+			break;
+		case _NET_WM_STATE_TOGGLE:
+			handlers[i].toggle(cc);
+		}
+	}
+}
+
+void
+xu_ewmh_restore_net_wm_state(struct client_ctx *cc)
+{
+	Atom	*atoms;
+	int	 i, n;
+
+	atoms = xu_ewmh_get_net_wm_state(cc, &n);
+	for (i = 0; i < n; i++) {
+		if (atoms[i] == ewmh[_NET_WM_STATE_STICKY])
+			client_toggle_sticky(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_MAXIMIZED_VERT])
+			client_toggle_vmaximize(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_MAXIMIZED_HORZ])
+			client_toggle_hmaximize(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_HIDDEN])
+			client_toggle_hidden(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_FULLSCREEN])
+			client_toggle_fullscreen(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_DEMANDS_ATTENTION])
+			client_urgency(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_SKIP_PAGER])
+			client_toggle_skip_pager(cc);
+		if (atoms[i] == ewmh[_NET_WM_STATE_SKIP_TASKBAR])
+			client_toggle_skip_taskbar(cc);
+		if (atoms[i] == ewmh[_CWM_WM_STATE_FREEZE])
+			client_toggle_freeze(cc);
+	}
+	free(atoms);
+}
+
+void
+xu_ewmh_set_net_wm_state(struct client_ctx *cc)
+{
+	Atom	*atoms, *oatoms;
+	int	 n, i, j;
+
+	oatoms = xu_ewmh_get_net_wm_state(cc, &n);
+	atoms = xreallocarray(NULL, (n + _NET_WM_STATES_NITEMS), sizeof(Atom));
+	for (i = j = 0; i < n; i++) {
+		if (oatoms[i] != ewmh[_NET_WM_STATE_STICKY] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_MAXIMIZED_VERT] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_MAXIMIZED_HORZ] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_HIDDEN] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_FULLSCREEN] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_DEMANDS_ATTENTION] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_SKIP_PAGER] &&
+		    oatoms[i] != ewmh[_NET_WM_STATE_SKIP_TASKBAR] &&
+		    oatoms[i] != ewmh[_CWM_WM_STATE_FREEZE])
+			atoms[j++] = oatoms[i];
+	}
+	free(oatoms);
+	if (cc->flags & CLIENT_STICKY)
+		atoms[j++] = ewmh[_NET_WM_STATE_STICKY];
+	if (cc->flags & CLIENT_HIDDEN)
+		atoms[j++] = ewmh[_NET_WM_STATE_HIDDEN];
+	if (cc->flags & CLIENT_FULLSCREEN)
+		atoms[j++] = ewmh[_NET_WM_STATE_FULLSCREEN];
+	else {
+		if (cc->flags & CLIENT_VMAXIMIZED)
+			atoms[j++] = ewmh[_NET_WM_STATE_MAXIMIZED_VERT];
+		if (cc->flags & CLIENT_HMAXIMIZED)
+			atoms[j++] = ewmh[_NET_WM_STATE_MAXIMIZED_HORZ];
+	}
+	if (cc->flags & CLIENT_URGENCY)
+		atoms[j++] = ewmh[_NET_WM_STATE_DEMANDS_ATTENTION];
+	if (cc->flags & CLIENT_SKIP_PAGER)
+		atoms[j++] = ewmh[_NET_WM_STATE_SKIP_PAGER];
+	if (cc->flags & CLIENT_SKIP_TASKBAR)
+		atoms[j++] = ewmh[_NET_WM_STATE_SKIP_TASKBAR];
+	if (cc->flags & CLIENT_FREEZE)
+		atoms[j++] = ewmh[_CWM_WM_STATE_FREEZE];
+	if (j > 0)
+		XChangeProperty(X_Dpy, cc->win, ewmh[_NET_WM_STATE],
+		    XA_ATOM, 32, PropModeReplace, (unsigned char *)atoms, j);
+	else
+		XDeleteProperty(X_Dpy, cc->win, ewmh[_NET_WM_STATE]);
+	free(atoms);
 }