cvsimport

* refs/heads/master:
  cwm: fix a semi-transparency border issue with some applications

Makefile

@@ -11,26 +11,25 @@ SRCS=		calmwm.c screen.c xmalloc.c client.c menu.c \
 
 OBJS=		calmwm.o screen.o xmalloc.o client.o menu.o \
 		search.o util.o xutil.o conf.o xevents.o group.o \
-		kbfunc.o strlcpy.o strlcat.o y.tab.o \
+		kbfunc.o strlcpy.o strlcat.o parse.o \
 		strtonum.o reallocarray.o
+		
+PKG_CONFIG?=	pkg-config
 
-CPPFLAGS+=	`pkg-config --cflags fontconfig x11 xft xrandr`
+CPPFLAGS+=	`${PKG_CONFIG} --cflags x11 xft xrandr`
 
 CFLAGS?=	-Wall -O2 -g -D_GNU_SOURCE
 
-LDFLAGS+=	`pkg-config --libs fontconfig x11 xft xrandr`
+LDFLAGS+=	`${PKG_CONFIG} --libs x11 xft xrandr`
 
 MANPREFIX?=	${PREFIX}/share/man
 
 all: ${PROG}
 
 clean:
-	rm -f ${OBJS} ${PROG} y.tab.c
+	rm -f ${OBJS} ${PROG} parse.c
 
-y.tab.c: parse.y
-	yacc parse.y
-
-${PROG}: ${OBJS} y.tab.o
+${PROG}: ${OBJS}
 	${CC} ${OBJS} ${LDFLAGS} -o ${PROG}
 
 .c.o:
@@ -48,6 +47,8 @@ release:
 
 sign:
 	VERSION=$$(git describe --tags | sed 's/^v//;s/-[^.]*$$//') && \
-	gpg --armor --detach-sign cwm-$$VERSION.tar.gz && \
+	gpg2 --armor --detach-sign cwm-$$VERSION.tar.gz && \
 	signify -S -s ~/.signify/cwm.sec -m cwm-$$VERSION.tar.gz && \
 	sed -i '1cuntrusted comment: verify with cwm.pub' cwm-$$VERSION.tar.gz.sig
+
+.PRECIOUS: parse.c

README

@@ -1,5 +1,4 @@
-This is a port of OpenBSD's excellent cwm[0] to Linux and other
-Unices.
+This is a port of OpenBSD's excellent cwm[0] to Linux and other Unices.
 
     cwm is a window manager for X11 which contains many features that
     concentrate on the efficiency and transparency of window
@@ -13,10 +12,11 @@ OpenBSD, FreeBSD, NetBSD, OS X 10.9 and Linux.
 This version actively tracks changes in the OpenBSD CVS repository.
 Releases are roughly coordinated.
 
-The revision controlled version is at https://github.com/chneukirchen/cwm
-Releases can be found at http://chneukirchen.org/releases
+The revision controlled version is at https://github.com/leahneukirchen/cwm
+Releases can be found at http://leahneukirchen.org/releases
 
-You are welcome to join the IRC channel ##cwm on Freenode to talk about cwm.
+You are welcome to join the IRC channel ##cwm on irc.libera.chat
+to talk about cwm.
 
 
 ChangeLog:
@@ -107,6 +107,41 @@ Changes made between OpenBSD 5.8 and 5.9
 
 2017-10-17: Fourth public release 6.2 of portable cwm.
 
+Changes made between OpenBSD 6.2 and 6.3
+* Fix blocking bug during moving or resizing.
+* window-snap-* commands to move windows to edges and corners.
+* Add support for _NET_WM_STATE_SKIP_PAGER and _NET_WM_STATE_SKIP_TASKBAR.
+* Add support for re-exec'ing with SIGHUP.
+
+2018-05-14: Fifth public release 6.3 of portable cwm.
+
+2020-01-04: Sixth public release 6.6 of portable cwm.
+
+Changes made between OpenBSD 6.4 and 6.5
+* Added a configtest flag (-n) to cwm(1).
+* Introduced 'group-close-[n]' action to cwm(1) to close all windows
+  within a specified group.
+
+2020-05-22: Seventh public release 6.7 of portable cwm.
+
+Changes made between OpenBSD 6.6 and 6.7
+* Allowed cwm(1) configuration of window size based on percentage of
+  the master window during horizontal and vertical tiling actions.
+* Allowed use of window-htile and window-vtile with the "empty" group
+  clients in cwm(1).
+
+2022-04-30: Eighth public release 7.1 of portable cwm.
+
+Changes made between OpenBSD 6.9 and 7.0
+* Changed cwm(1) maximization and full-screen mode toggling to keep
+  the cursor within the window, preventing focus loss.
+
+Changes made between OpenBSD 7.0 and 7.1
+* Added a cwm(1) "group-last" command that shows only the previously
+  active group.
+* Allowed bare numbers for key and mouse bindings in cwm(1).
+
+
 --Leah Neukirchen <leah@vuxu.org>
 
 [0]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/xenocara/app/cwm/

calmwm.c

@@ -27,7 +27,7 @@
 #include <getopt.h>
 #include <limits.h>
 #include <locale.h>
-#include <pwd.h>
+#include <poll.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -42,36 +42,46 @@ Atom			 cwmh[CWMH_NITEMS];
 Atom			 ewmh[EWMH_NITEMS];
 struct screen_q		 Screenq = TAILQ_HEAD_INITIALIZER(Screenq);
 struct conf		 Conf;
-const char		*homedir;
 volatile sig_atomic_t	 cwm_status;
 
+void	usage(void);
 static void	sighdlr(int);
 static int	x_errorhandler(Display *, XErrorEvent *);
-static void	x_init(const char *);
+static int	x_init(const char *);
 static void	x_teardown(void);
 static int	x_wmerrorhandler(Display *, XErrorEvent *);
 
 int
 main(int argc, char **argv)
 {
-	const char	*conf_file = NULL;
-	char		*conf_path, *display_name = NULL;
-	int		 ch;
-	struct passwd	*pw;
+	char		*display_name = NULL;
+	char		*fallback;
+	int		 ch, xfd, nflag = 0;
+	struct pollfd	 pfd[1];
 
 	if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
 		warnx("no locale support");
 	mbtowc(NULL, NULL, MB_CUR_MAX);
 
+	conf_init(&Conf);
+
+	fallback = u_argv(argv);
 	Conf.wm_argv = u_argv(argv);
-	while ((ch = getopt(argc, argv, "c:d:")) != -1) {
+	while ((ch = getopt(argc, argv, "c:d:nv")) != -1) {
 		switch (ch) {
 		case 'c':
-			conf_file = optarg;
+			free(Conf.conf_file);
+			Conf.conf_file = xstrdup(optarg);
 			break;
 		case 'd':
 			display_name = optarg;
 			break;
+		case 'n':
+			nflag = 1;
+			break;
+		case 'v':
+			Conf.debug++;
+			break;
 		default:
 			usage();
 		}
@@ -79,36 +89,21 @@ main(int argc, char **argv)
 	argc -= optind;
 	argv += optind;
 
-	if (signal(SIGCHLD, sighdlr) == SIG_ERR)
+	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 ((homedir = getenv("HOME")) == NULL || *homedir == '\0') {
-		pw = getpwuid(getuid());
-		if (pw != NULL && pw->pw_dir != NULL && *pw->pw_dir != '\0')
-			homedir = pw->pw_dir;
-		else
-			homedir = "/";
+	if (parse_config(Conf.conf_file, &Conf) == -1) {
+		warnx("error parsing config file");
+		if (nflag)
+			return 1;
 	}
+	if (nflag)
+		return 0;
 
-	if (conf_file == NULL)
-		xasprintf(&conf_path, "%s/%s", homedir, CONFFILE);
-	else
-		conf_path = xstrdup(conf_file);
-
-	if (access(conf_path, R_OK) != 0) {
-		if (conf_file != NULL)
-			warn("%s", conf_file);
-		free(conf_path);
-		conf_path = NULL;
-	}
-
-	conf_init(&Conf);
-
-	if (conf_path && (parse_config(conf_path, &Conf) == -1))
-		warnx("config file %s has errors", conf_path);
-	free(conf_path);
-
-	x_init(display_name);
+	xfd = x_init(display_name);
 	cwm_status = CWM_RUNNING;
 
 #ifdef __OpenBSD__
@@ -116,16 +111,27 @@ main(int argc, char **argv)
 		err(1, "pledge");
 #endif
 
-	while (cwm_status == CWM_RUNNING)
+	memset(&pfd, 0, sizeof(pfd));
+	pfd[0].fd = xfd;
+	pfd[0].events = POLLIN;
+	while (cwm_status == CWM_RUNNING) {
 		xev_process();
+		if (poll(pfd, 1, -1) == -1) {
+			if (errno != EINTR)
+				warn("poll");
+		}
+	}
 	x_teardown();
-	if (cwm_status == CWM_EXEC_WM)
+	if (cwm_status == CWM_EXEC_WM) {
 		u_exec(Conf.wm_argv);
+		warnx("'%s' failed to start, starting fallback", Conf.wm_argv);
+		u_exec(fallback);
+	}
 
-	return(0);
+	return 0;
 }
 
-static void
+static int
 x_init(const char *dpyname)
 {
 	int	i;
@@ -140,11 +146,13 @@ x_init(const char *dpyname)
 
 	Conf.xrandr = XRRQueryExtension(X_Dpy, &Conf.xrandr_event_base, &i);
 
-	conf_atoms();
+	xu_atom_init();
 	conf_cursor(&Conf);
 
 	for (i = 0; i < ScreenCount(X_Dpy); i++)
 		screen_init(i);
+
+	return ConnectionNumber(X_Dpy);
 }
 
 static void
@@ -161,8 +169,6 @@ x_teardown(void)
 			    DefaultColormap(X_Dpy, sc->which),
 			    &sc->xftcolor[i]);
 		XftFontClose(X_Dpy, sc->xftfont);
-		XftDrawDestroy(sc->menu.xftdraw);
-		XDestroyWindow(X_Dpy, sc->menu.win);
 		XUngrabKey(X_Dpy, AnyKey, AnyModifier, sc->rootwin);
 	}
 	XUngrabPointer(X_Dpy, CurrentTime);
@@ -178,8 +184,7 @@ static int
 x_wmerrorhandler(Display *dpy, XErrorEvent *e)
 {
 	errx(1, "root window unavailable - perhaps another wm is running?");
-
-	return(0);
+	return 0;
 }
 
 static int
@@ -195,7 +200,7 @@ x_errorhandler(Display *dpy, XErrorEvent *e)
 
 	warnx("%s(0x%x): %s", req, (unsigned int)e->resourceid, msg);
 #endif
-	return(0);
+	return 0;
 }
 
 static void
@@ -211,6 +216,13 @@ sighdlr(int sig)
 		    (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;
@@ -221,7 +233,7 @@ usage(void)
 {
 	extern char	*__progname;
 
-	(void)fprintf(stderr, "usage: %s [-c file] [-d display]\n",
+	(void)fprintf(stderr, "usage: %s [-nv] [-c file] [-d display]\n",
 	    __progname);
 	exit(1);
 }

calmwm.h

@@ -52,6 +52,11 @@ size_t strlcpy(char *, const char *, size_t);
 #include <X11/extensions/Xrandr.h>
 #include <X11/keysym.h>
 
+#define LOG_DEBUG0(...)	log_debug(0, __func__, __VA_ARGS__)
+#define LOG_DEBUG1(...)	log_debug(1, __func__, __VA_ARGS__)
+#define LOG_DEBUG2(...)	log_debug(2, __func__, __VA_ARGS__)
+#define LOG_DEBUG3(...)	log_debug(3, __func__, __VA_ARGS__)
+
 #undef MIN
 #undef MAX
 #define MIN(x, y) ((x) < (y) ? (x) : (y))
@@ -61,13 +66,8 @@ size_t strlcpy(char *, const char *, size_t);
 #define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
 #endif
 
-#define	CONFFILE	".cwmrc"
-
 #define BUTTONMASK	(ButtonPressMask | ButtonReleaseMask)
 #define MOUSEMASK	(BUTTONMASK | PointerMotionMask)
-#define MENUMASK 	(MOUSEMASK | ButtonMotionMask | ExposureMask)
-#define MENUGRABMASK	(MOUSEMASK | ButtonMotionMask | StructureNotifyMask)
-#define KEYMASK		(KeyPressMask | ExposureMask)
 #define IGNOREMODMASK	(LockMask | Mod2Mask | 0x2000)
 
 /* direction/amount */
@@ -76,7 +76,14 @@ size_t strlcpy(char *, const char *, size_t);
 #define CWM_LEFT		0x0004
 #define CWM_RIGHT		0x0008
 #define CWM_BIGAMOUNT		0x0010
-#define DIRECTIONMASK	(CWM_UP | CWM_DOWN | CWM_LEFT | CWM_RIGHT)
+#define CWM_UP_BIG		(CWM_UP | CWM_BIGAMOUNT)
+#define CWM_DOWN_BIG		(CWM_DOWN | CWM_BIGAMOUNT)
+#define CWM_LEFT_BIG		(CWM_LEFT | CWM_BIGAMOUNT)
+#define CWM_RIGHT_BIG		(CWM_RIGHT | CWM_BIGAMOUNT)
+#define CWM_UP_RIGHT		(CWM_UP | CWM_RIGHT)
+#define CWM_UP_LEFT		(CWM_UP | CWM_LEFT)
+#define CWM_DOWN_RIGHT		(CWM_DOWN | CWM_RIGHT)
+#define CWM_DOWN_LEFT		(CWM_DOWN | CWM_LEFT)
 
 #define CWM_CYCLE_FORWARD	0x0001
 #define CWM_CYCLE_REVERSE	0x0002
@@ -113,11 +120,6 @@ struct geom {
 	int		 w;
 	int		 h;
 };
-
-enum apply_gap {
-	CWM_NOGAP = 0,
-	CWM_GAP
-};
 struct gap {
 	int		 top;
 	int		 bottom;
@@ -134,12 +136,12 @@ TAILQ_HEAD(ignore_q, winname);
 
 struct client_ctx {
 	TAILQ_ENTRY(client_ctx)	 entry;
-	TAILQ_ENTRY(client_ctx)	 group_entry;
 	struct screen_ctx	*sc;
 	struct group_ctx	*gc;
 	Window			 win;
 	Colormap		 colormap;
 	int			 bwidth; /* border width */
+	int			 obwidth; /* original border width */
 	struct geom		 geom, savegeom, fullgeom;
 	struct {
 		long		 flags;	/* defined hints */
@@ -176,6 +178,11 @@ struct client_ctx {
 #define CLIENT_FULLSCREEN		0x0800
 #define CLIENT_STICKY			0x1000
 #define CLIENT_ACTIVE			0x2000
+#define CLIENT_SKIP_PAGER		0x4000
+#define CLIENT_SKIP_TASKBAR		0x8000
+
+#define CLIENT_SKIP_CYCLE		(CLIENT_HIDDEN | CLIENT_IGNORE | \
+					 CLIENT_SKIP_TASKBAR | CLIENT_SKIP_PAGER)
 #define CLIENT_HIGHLIGHT		(CLIENT_GROUP | CLIENT_UNGROUP)
 #define CLIENT_MAXFLAGS			(CLIENT_VMAXIMIZED | CLIENT_HMAXIMIZED)
 #define CLIENT_MAXIMIZED		(CLIENT_VMAXIMIZED | CLIENT_HMAXIMIZED)
@@ -184,8 +191,9 @@ struct client_ctx {
 	struct name_q		 nameq;
 	char			*name;
 	char			*label;
-	XClassHint		ch;
-	XWMHints		*wmh;
+	char			*res_class; /* class hint */
+	char			*res_name; /* class hint */
+	int			 initial_state; /* wm hint */
 };
 TAILQ_HEAD(client_q, client_ctx);
 
@@ -194,7 +202,6 @@ struct group_ctx {
 	struct screen_ctx	*sc;
 	char			*name;
 	int			 num;
-	struct client_q		 clientq;
 };
 TAILQ_HEAD(group_q, group_ctx);
 
@@ -209,7 +216,6 @@ TAILQ_HEAD(autogroup_q, autogroup);
 struct region_ctx {
 	TAILQ_ENTRY(region_ctx)	 entry;
 	int			 num;
-	struct geom		 area;
 	struct geom		 view; /* viewable area */
 	struct geom		 work; /* workable area, gap-applied */
 };
@@ -229,10 +235,13 @@ struct screen_ctx {
 	struct region_q		 regionq;
 	struct group_q		 groupq;
 	struct group_ctx	*group_active;
+	struct group_ctx	*group_last;
+	Colormap		 colormap;
+	Visual			*visual;
 	struct {
 		Window		 win;
 		XftDraw		*xftdraw;
-	} menu;
+	} prop;
 	XftColor		 xftcolor[CWM_COLOR_NITEMS];
 	XftFont			*xftfont;
 };
@@ -268,14 +277,11 @@ TAILQ_HEAD(mousebind_q, bind_ctx);
 struct cmd_ctx {
 	TAILQ_ENTRY(cmd_ctx)	 entry;
 	char			*name;
-	char			 path[PATH_MAX];
+	char			*path;
 };
 TAILQ_HEAD(cmd_q, cmd_ctx);
+TAILQ_HEAD(wm_q, cmd_ctx);
 
-enum menu_exec {
-	CWM_MENU_EXEC_EXEC,
-	CWM_MENU_EXEC_WM
-};
 #define CWM_MENU_DUMMY		0x0001
 #define CWM_MENU_FILE		0x0002
 #define CWM_MENU_LIST		0x0004
@@ -300,49 +306,63 @@ struct conf {
 	struct autogroup_q	 autogroupq;
 	struct ignore_q		 ignoreq;
 	struct cmd_q		 cmdq;
+	struct wm_q		 wmq;
 	int			 ngroups;
 	int			 stickygroups;
 	int			 nameqlen;
 	int			 bwidth;
 	int			 mamount;
 	int			 snapdist;
+	int			 htile;
+	int			 vtile;
 	struct gap		 gap;
 	char			*color[CWM_COLOR_NITEMS];
-	char			 known_hosts[PATH_MAX];
 	char			*font;
 	char			*wmname;
 	Cursor			 cursor[CF_NITEMS];
 	int			 xrandr;
 	int			 xrandr_event_base;
+	char			*conf_file;
+	char			*known_hosts;
 	char			*wm_argv;
+	int			 debug;
 };
 
 /* MWM hints */
 struct mwm_hints {
-#define MWM_HINTS_ELEMENTS	3L
-#define MWM_FLAGS_STATUS	(1<<3)
+#define MWM_HINTS_ELEMENTS	5L
 
-#define MWM_FLAGS_FUNCTIONS	(1<<0)
-#define MWM_FLAGS_DECORATIONS	(1<<1)
-#define MWM_FLAGS_INPUT_MODE	(1<<2)
+#define MWM_HINTS_FUNCTIONS	(1L << 0)
+#define MWM_HINTS_DECORATIONS	(1L << 1)
+#define MWM_HINTS_INPUT_MODE	(1L << 2)
+#define MWM_HINTS_STATUS	(1L << 3)
 	unsigned long	flags;
 
-#define MWM_FUNCS_ALL		(1<<0)
-#define MWM_FUNCS_RESIZE	(1<<1)
-#define MWM_FUNCS_MOVE		(1<<2)
-#define MWM_FUNCS_MINIMIZE	(1<<3)
-#define MWM_FUNCS_MAXIMIZE	(1<<4)
-#define MWM_FUNCS_CLOSE		(1<<5)
+#define MWM_FUNC_ALL		(1L << 0)
+#define MWM_FUNC_RESIZE		(1L << 1)
+#define MWM_FUNC_MOVE		(1L << 2)
+#define MWM_FUNC_MINIMIZE	(1L << 3)
+#define MWM_FUNC_MAXIMIZE	(1L << 4)
+#define MWM_FUNC_CLOSE		(1L << 5)
 	unsigned long	functions;
 
-#define	MWM_DECOR_ALL		(1<<0)
-#define	MWM_DECOR_BORDER	(1<<1)
-#define MWM_DECOR_RESIZE_HANDLE	(1<<2)
-#define MWM_DECOR_TITLEBAR	(1<<3)
-#define MWM_DECOR_MENU		(1<<4)
-#define MWM_DECOR_MINIMIZE	(1<<5)
-#define MWM_DECOR_MAXIMIZE	(1<<6)
+#define	MWM_DECOR_ALL		(1L << 0)
+#define	MWM_DECOR_BORDER	(1L << 1)
+#define MWM_DECOR_RESIZEH	(1L << 2)
+#define MWM_DECOR_TITLE		(1L << 3)
+#define MWM_DECOR_MENU		(1L << 4)
+#define MWM_DECOR_MINIMIZE	(1L << 5)
+#define MWM_DECOR_MAXIMIZE	(1L << 6)
 	unsigned long	decorations;
+
+#define MWM_INPUT_MODELESS			0
+#define MWM_INPUT_PRIMARY_APPLICATION_MODAL	1
+#define MWM_INPUT_SYSTEM_MODAL			2
+#define MWM_INPUT_FULL_APPLICATION_MODAL	3
+	long		inputMode;
+
+#define MWM_TEAROFF_WINDOW	(1L << 0)
+	unsigned long	status;
 };
 
 enum cwmh {
@@ -373,13 +393,15 @@ enum ewmh {
 	_NET_WM_DESKTOP,
 	_NET_CLOSE_WINDOW,
 	_NET_WM_STATE,
-#define	_NET_WM_STATES_NITEMS	7
+#define	_NET_WM_STATES_NITEMS	9
 	_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,
 	EWMH_NITEMS
 };
@@ -395,96 +417,106 @@ extern Atom				 cwmh[CWMH_NITEMS];
 extern Atom				 ewmh[EWMH_NITEMS];
 extern struct screen_q			 Screenq;
 extern struct conf			 Conf;
-extern const char			*homedir;
 
 void			 usage(void);
 
-void			 client_applysizehints(struct client_ctx *);
+void			 client_apply_sizehints(struct client_ctx *);
+void			 client_close(struct client_ctx *);
 void			 client_config(struct client_ctx *);
-struct client_ctx	*client_current(void);
-void			 client_cycle(struct screen_ctx *, int);
-void			 client_cycle_leave(struct screen_ctx *);
-void			 client_delete(struct client_ctx *);
+struct client_ctx	*client_current(struct screen_ctx *);
 void			 client_draw_border(struct client_ctx *);
 struct client_ctx	*client_find(Window);
-long			 client_get_wm_state(struct client_ctx *);
-void			 client_getsizehints(struct client_ctx *);
+void			 client_get_sizehints(struct client_ctx *);
 void			 client_hide(struct client_ctx *);
 void 			 client_htile(struct client_ctx *);
-void			 client_lower(struct client_ctx *);
-void			 client_map(struct client_ctx *);
-void			 client_msg(struct client_ctx *, Atom, Time);
-void			 client_move(struct client_ctx *);
 int			 client_inbound(struct client_ctx *, int, int);
-struct client_ctx	*client_init(Window, struct screen_ctx *, int);
+struct client_ctx	*client_init(Window, struct screen_ctx *);
+void			 client_lower(struct client_ctx *);
+void			 client_move(struct client_ctx *);
+void			 client_mtf(struct client_ctx *);
+struct client_ctx	*client_next(struct client_ctx *);
+struct client_ctx	*client_prev(struct client_ctx *);
 void			 client_ptr_inbound(struct client_ctx *, int);
-void			 client_ptrsave(struct client_ctx *);
-void			 client_ptrwarp(struct client_ctx *);
+void			 client_ptr_save(struct client_ctx *);
+void			 client_ptr_warp(struct client_ctx *);
 void			 client_raise(struct client_ctx *);
+void			 client_remove(struct client_ctx *);
 void			 client_resize(struct client_ctx *, int);
-void			 client_send_delete(struct client_ctx *);
-void			 client_set_wm_state(struct client_ctx *, long);
-void			 client_setactive(struct client_ctx *);
-void			 client_setname(struct client_ctx *);
+void			 client_set_active(struct client_ctx *);
+void			 client_set_name(struct client_ctx *);
+void			 client_show(struct client_ctx *);
 int			 client_snapcalc(int, int, int, int, int);
-void			 client_toggle_freeze(struct client_ctx *);
-void			 client_toggle_fullscreen(struct client_ctx *);
 void			 client_toggle_hidden(struct client_ctx *);
 void			 client_toggle_hmaximize(struct client_ctx *);
+void			 client_toggle_fullscreen(struct client_ctx *);
+void			 client_toggle_freeze(struct client_ctx *);
 void			 client_toggle_maximize(struct client_ctx *);
+void			 client_toggle_skip_pager(struct client_ctx *);
+void			 client_toggle_skip_taskbar(struct client_ctx *);
 void			 client_toggle_sticky(struct client_ctx *);
 void			 client_toggle_vmaximize(struct client_ctx *);
 void			 client_transient(struct client_ctx *);
-void			 client_unhide(struct client_ctx *);
 void			 client_urgency(struct client_ctx *);
 void 			 client_vtile(struct client_ctx *);
 void			 client_wm_hints(struct client_ctx *);
 
-void			 group_alltoggle(struct screen_ctx *);
 void			 group_assign(struct group_ctx *, struct client_ctx *);
 int			 group_autogroup(struct client_ctx *);
 void			 group_cycle(struct screen_ctx *, int);
 void			 group_hide(struct group_ctx *);
-void			 group_hidetoggle(struct screen_ctx *, int);
 int			 group_holds_only_hidden(struct group_ctx *);
 int			 group_holds_only_sticky(struct group_ctx *);
-void			 group_init(struct screen_ctx *, int);
+void			 group_init(struct screen_ctx *, int, const char *);
 void			 group_movetogroup(struct client_ctx *, int);
 void			 group_only(struct screen_ctx *, int);
+void			 group_close(struct screen_ctx *, int);
 int			 group_restore(struct client_ctx *);
 void			 group_show(struct group_ctx *);
-void			 group_toggle_membership_enter(struct client_ctx *);
-void			 group_toggle_membership_leave(struct client_ctx *);
+void			 group_toggle(struct screen_ctx *, int);
+void			 group_toggle_all(struct screen_ctx *);
+void			 group_toggle_membership(struct client_ctx *);
 void			 group_update_names(struct screen_ctx *);
 
 void			 search_match_client(struct menu_q *, struct menu_q *,
 			     char *);
+void			 search_match_cmd(struct menu_q *, struct menu_q *,
+			     char *);
 void			 search_match_exec(struct menu_q *, struct menu_q *,
 			     char *);
+void			 search_match_group(struct menu_q *, struct menu_q *,
+			     char *);
 void			 search_match_path(struct menu_q *, struct menu_q *,
 			     char *);
 void			 search_match_text(struct menu_q *, struct menu_q *,
 			     char *);
+void			 search_match_wm(struct menu_q *, struct menu_q *,
+			     char *);
 void			 search_print_client(struct menu *, int);
 void			 search_print_cmd(struct menu *, int);
 void			 search_print_group(struct menu *, int);
 void			 search_print_text(struct menu *, int);
+void			 search_print_wm(struct menu *, int);
 
 struct region_ctx	*region_find(struct screen_ctx *, int, int);
-struct geom		 screen_apply_gap(struct screen_ctx *, struct geom);
+void			 screen_assert_clients_within(struct screen_ctx *);
+struct geom		 screen_area(struct screen_ctx *, int, int, int);
 struct screen_ctx	*screen_find(Window);
-struct geom		 screen_area(struct screen_ctx *, int, int,
-			     enum apply_gap);
 void			 screen_init(int);
+void			 screen_prop_win_create(struct screen_ctx *, Window);
+void			 screen_prop_win_destroy(struct screen_ctx *);
+void			 screen_prop_win_draw(struct screen_ctx *,
+			     const char *, ...)
+			    __attribute__((__format__ (printf, 2, 3)))
+			    __attribute__((__nonnull__ (2)));
 void			 screen_update_geometry(struct screen_ctx *);
 void			 screen_updatestackingorder(struct screen_ctx *);
-void			 screen_assert_clients_within(struct screen_ctx *);
 
 void			 kbfunc_cwm_status(void *, struct cargs *);
 void			 kbfunc_ptrmove(void *, struct cargs *);
+void			 kbfunc_client_snap(void *, struct cargs *);
 void			 kbfunc_client_move(void *, struct cargs *);
 void			 kbfunc_client_resize(void *, struct cargs *);
-void			 kbfunc_client_delete(void *, struct cargs *);
+void			 kbfunc_client_close(void *, struct cargs *);
 void			 kbfunc_client_lower(void *, struct cargs *);
 void			 kbfunc_client_raise(void *, struct cargs *);
 void			 kbfunc_client_hide(void *, struct cargs *);
@@ -502,11 +534,14 @@ void			 kbfunc_client_toggle_group(void *, struct cargs *);
 void			 kbfunc_client_movetogroup(void *, struct cargs *);
 void			 kbfunc_group_toggle(void *, struct cargs *);
 void			 kbfunc_group_only(void *, struct cargs *);
+void			 kbfunc_group_last(void *, struct cargs *);
+void			 kbfunc_group_close(void *, struct cargs *);
 void			 kbfunc_group_cycle(void *, struct cargs *);
-void			 kbfunc_group_alltoggle(void *, struct cargs *);
+void			 kbfunc_group_toggle_all(void *, struct cargs *);
 void			 kbfunc_menu_client(void *, struct cargs *);
 void			 kbfunc_menu_cmd(void *, struct cargs *);
 void			 kbfunc_menu_group(void *, struct cargs *);
+void			 kbfunc_menu_wm(void *, struct cargs *);
 void			 kbfunc_menu_exec(void *, struct cargs *);
 void			 kbfunc_menu_ssh(void *, struct cargs *);
 void			 kbfunc_client_menu_label(void *, struct cargs *);
@@ -514,18 +549,16 @@ void			 kbfunc_exec_cmd(void *, struct cargs *);
 void			 kbfunc_exec_lock(void *, struct cargs *);
 void			 kbfunc_exec_term(void *, struct cargs *);
 
-void			 menu_windraw(struct screen_ctx *, Window,
-			     const char *, ...);
 struct menu  		*menu_filter(struct screen_ctx *, struct menu_q *,
 			     const char *, const char *, int,
 			     void (*)(struct menu_q *, struct menu_q *, char *),
 			     void (*)(struct menu *, int));
-void			 menuq_add(struct menu_q *, void *, const char *, ...);
+void			 menuq_add(struct menu_q *, void *, const char *, ...)
+			    __attribute__((__format__ (printf, 3, 4)));
 void			 menuq_clear(struct menu_q *);
 
 int			 parse_config(const char *, struct conf *);
 
-void			 conf_atoms(void);
 void			 conf_autogroup(struct conf *, int, const char *,
 			     const char *);
 int			 conf_bind_key(struct conf *, const char *,
@@ -534,7 +567,9 @@ int			 conf_bind_mouse(struct conf *, const char *,
     			     const char *);
 void			 conf_clear(struct conf *);
 void			 conf_client(struct client_ctx *);
-int			 conf_cmd_add(struct conf *, const char *,
+void			 conf_cmd_add(struct conf *, const char *,
+			     const char *);
+void			 conf_wm_add(struct conf *, const char *,
 			     const char *);
 void			 conf_cursor(struct conf *);
 void			 conf_grab_kbd(Window);
@@ -542,40 +577,47 @@ void			 conf_grab_mouse(Window);
 void			 conf_init(struct conf *);
 void			 conf_ignore(struct conf *, const char *);
 void			 conf_screen(struct screen_ctx *);
+void			 conf_group(struct screen_ctx *);
 
 void			 xev_process(void);
 
-int			 xu_getprop(Window, Atom, Atom, long, unsigned char **);
-int			 xu_getstrprop(Window, Atom, char **);
-void			 xu_ptr_getpos(Window, int *, int *);
-void			 xu_ptr_setpos(Window, int, int);
+int			 xu_get_prop(Window, Atom, Atom, long, unsigned char **);
+int			 xu_get_strprop(Window, Atom, char **);
+void			 xu_ptr_get(Window, int *, int *);
+void			 xu_ptr_set(Window, int, int);
+void			 xu_get_wm_state(Window, long *);
+void			 xu_set_wm_state(Window, long);
+void			 xu_send_clientmsg(Window, Atom, Time);
 void 			 xu_xorcolor(XftColor, XftColor, XftColor *);
 
+void			 xu_atom_init(void);
 void			 xu_ewmh_net_supported(struct screen_ctx *);
 void			 xu_ewmh_net_supported_wm_check(struct screen_ctx *);
 void			 xu_ewmh_net_desktop_geometry(struct screen_ctx *);
+void			 xu_ewmh_net_desktop_viewport(struct screen_ctx *);
 void			 xu_ewmh_net_workarea(struct screen_ctx *);
 void			 xu_ewmh_net_client_list(struct screen_ctx *);
 void			 xu_ewmh_net_client_list_stacking(struct screen_ctx *);
 void			 xu_ewmh_net_active_window(struct screen_ctx *, Window);
-Window			 xu_ewmh_get_net_active_window(struct screen_ctx *);
-void			 xu_ewmh_net_wm_desktop_viewport(struct screen_ctx *);
-void			 xu_ewmh_net_wm_number_of_desktops(struct screen_ctx *);
+void			 xu_ewmh_net_number_of_desktops(struct screen_ctx *);
 void			 xu_ewmh_net_showing_desktop(struct screen_ctx *);
 void			 xu_ewmh_net_virtual_roots(struct screen_ctx *);
 void			 xu_ewmh_net_current_desktop(struct screen_ctx *);
 void			 xu_ewmh_net_desktop_names(struct screen_ctx *);
-
-void			 xu_ewmh_net_wm_desktop(struct client_ctx *);
+int			 xu_ewmh_get_net_wm_desktop(struct client_ctx *, long *);
+void			 xu_ewmh_set_net_wm_desktop(struct client_ctx *);
 Atom 			*xu_ewmh_get_net_wm_state(struct client_ctx *, int *);
 void 			 xu_ewmh_handle_net_wm_state_msg(struct client_ctx *,
-			     int, Atom , Atom);
+			     int, Atom, Atom);
 void 			 xu_ewmh_set_net_wm_state(struct client_ctx *);
 void 			 xu_ewmh_restore_net_wm_state(struct client_ctx *);
 
 char			*u_argv(char * const *);
 void			 u_exec(char *);
 void			 u_spawn(char *);
+void			 log_debug(int, const char *, const char *, ...)
+			    __attribute__((__format__ (printf, 3, 4)))
+			    __attribute__((__nonnull__ (3)));
 
 void			*xcalloc(size_t, size_t);
 void			*xmalloc(size_t);
@@ -584,5 +626,7 @@ char			*xstrdup(const char *);
 int			 xasprintf(char **, const char *, ...)
 			    __attribute__((__format__ (printf, 2, 3)))
 			    __attribute__((__nonnull__ (2)));
+int			 xvasprintf(char **, const char *, va_list)
+			    __attribute__((__nonnull__ (2)));
 
 #endif /* _CALMWM_H_ */

client.c

@@ -31,91 +31,87 @@
 
 #include "calmwm.h"
 
-static struct client_ctx	*client_next(struct client_ctx *);
-static struct client_ctx	*client_prev(struct client_ctx *);
-static void			 client_mtf(struct client_ctx *);
-static void			 client_placecalc(struct client_ctx *);
-static void			 client_wm_protocols(struct client_ctx *);
+static void			 client_class_hint(struct client_ctx *);
+static void			 client_placement(struct client_ctx *);
 static void			 client_mwm_hints(struct client_ctx *);
+static void			 client_wm_protocols(struct client_ctx *);
 
 struct client_ctx *
-client_init(Window win, struct screen_ctx *sc, int active)
+client_init(Window win, struct screen_ctx *sc)
 {
 	struct client_ctx	*cc;
 	XWindowAttributes	 wattr;
 	int			 mapped;
-	Window			 rwin, cwin;
-	int			 x, y, wx, wy;
-	unsigned int		 mask;
+	long			 state;
 
 	if (win == None)
-		return(NULL);
+		return NULL;
 	if (!XGetWindowAttributes(X_Dpy, win, &wattr))
-		return(NULL);
+		return NULL;
 
 	if (sc == NULL) {
 		if ((sc = screen_find(wattr.root)) == NULL)
-			return(NULL);
+			return NULL;
 		mapped = 1;
 	} else {
 		if (wattr.override_redirect || wattr.map_state != IsViewable)
-			return(NULL);
+			return NULL;
 		mapped = wattr.map_state != IsUnmapped;
 	}
 
-	cc = xmalloc(sizeof(*cc));
-
 	XGrabServer(X_Dpy);
 
+	cc = xmalloc(sizeof(*cc));
 	cc->sc = sc;
 	cc->win = win;
+	cc->name = NULL;
 	cc->label = NULL;
 	cc->gc = NULL;
+	cc->res_class = NULL;
+	cc->res_name = NULL;
 	cc->flags = 0;
 	cc->stackingorder = 0;
+	cc->initial_state = 0;
 	memset(&cc->hint, 0, sizeof(cc->hint));
-	memset(&cc->ch, 0, sizeof(cc->ch));
-
 	TAILQ_INIT(&cc->nameq);
-	client_setname(cc);
-
-	conf_client(cc);
-
-	XGetClassHint(X_Dpy, cc->win, &cc->ch);
-	client_wm_hints(cc);
-	client_wm_protocols(cc);
-	client_getsizehints(cc);
-	client_mwm_hints(cc);
 
 	cc->geom.x = wattr.x;
 	cc->geom.y = wattr.y;
 	cc->geom.w = wattr.width;
 	cc->geom.h = wattr.height;
+	cc->colormap = wattr.colormap;
+	cc->obwidth = wattr.border_width;
+	cc->bwidth = Conf.bwidth;
+
+	client_set_name(cc);
+	conf_client(cc);
+
+	client_wm_hints(cc);
+	client_class_hint(cc);
+	client_wm_protocols(cc);
+	client_get_sizehints(cc);
+	client_transient(cc);
+	client_mwm_hints(cc);
+
+	if ((cc->flags & CLIENT_IGNORE))
+		cc->bwidth = 0;
 	cc->dim.w = (cc->geom.w - cc->hint.basew) / cc->hint.incw;
 	cc->dim.h = (cc->geom.h - cc->hint.baseh) / cc->hint.inch;
 	cc->ptr.x = cc->geom.w / 2;
 	cc->ptr.y = cc->geom.h / 2;
 
-	cc->colormap = wattr.colormap;
-
 	if (wattr.map_state != IsViewable) {
-		client_placecalc(cc);
+		client_placement(cc);
 		client_resize(cc, 0);
-		if ((cc->wmh) && (cc->wmh->flags & StateHint))
-			client_set_wm_state(cc, cc->wmh->initial_state);
-	} else {
-		if ((active == 0) && (XQueryPointer(X_Dpy, cc->win, &rwin, &cwin,
-		    &x, &y, &wx, &wy, &mask)) && (cwin != None))
-			active = 1;
+		if (cc->initial_state)
+			xu_set_wm_state(cc->win, cc->initial_state);
 	}
 
-	XSelectInput(X_Dpy, cc->win, ColormapChangeMask | EnterWindowMask |
-	    PropertyChangeMask | KeyReleaseMask);
+	XSelectInput(X_Dpy, cc->win,
+	    EnterWindowMask | PropertyChangeMask | KeyReleaseMask);
 
 	XAddToSaveSet(X_Dpy, cc->win);
 
-	client_transient(cc);
-
 	/* Notify client of its configuration. */
 	client_config(cc);
 
@@ -125,12 +121,17 @@ client_init(Window win, struct screen_ctx *sc, int active)
 	xu_ewmh_net_client_list_stacking(sc);
 	xu_ewmh_restore_net_wm_state(cc);
 
-	if (client_get_wm_state(cc) == IconicState)
+	xu_get_wm_state(cc->win, &state);
+	if (state == IconicState)
 		client_hide(cc);
 	else
-		client_unhide(cc);
+		client_show(cc);
 
 	if (mapped) {
+		if (cc->gc) {
+			group_movetogroup(cc, cc->gc->num);
+			goto out;
+		}
 		if (group_restore(cc))
 			goto out;
 		if (group_autogroup(cc))
@@ -144,10 +145,29 @@ out:
 	XSync(X_Dpy, False);
 	XUngrabServer(X_Dpy);
 
-	if (active)
-		client_setactive(cc);
+	return cc;
+}
 
-	return(cc);
+struct client_ctx *
+client_current(struct screen_ctx *sc)
+{
+	struct screen_ctx	*_sc;
+	struct client_ctx	*cc;
+
+	if (sc) {
+		TAILQ_FOREACH(cc, &sc->clientq, entry) {
+			if (cc->flags & CLIENT_ACTIVE)
+				return cc;
+		}
+	} else {
+		TAILQ_FOREACH(_sc, &Screenq, entry) {
+			TAILQ_FOREACH(cc, &_sc->clientq, entry) {
+				if (cc->flags & CLIENT_ACTIVE)
+					return cc;
+			}
+		}
+	}
+	return NULL;
 }
 
 struct client_ctx *
@@ -159,14 +179,34 @@ client_find(Window win)
 	TAILQ_FOREACH(sc, &Screenq, entry) {
 		TAILQ_FOREACH(cc, &sc->clientq, entry) {
 			if (cc->win == win)
-				return(cc);
+				return cc;
 		}
 	}
-	return(NULL);
+	return NULL;
+}
+
+struct client_ctx *
+client_next(struct client_ctx *cc)
+{
+	struct screen_ctx	*sc = cc->sc;
+	struct client_ctx	*newcc;
+
+	return(((newcc = TAILQ_NEXT(cc, entry)) != NULL) ?
+	    newcc : TAILQ_FIRST(&sc->clientq));
+}
+
+struct client_ctx *
+client_prev(struct client_ctx *cc)
+{
+	struct screen_ctx	*sc = cc->sc;
+	struct client_ctx	*newcc;
+
+	return(((newcc = TAILQ_PREV(cc, client_q, entry)) != NULL) ?
+	    newcc : TAILQ_LAST(&sc->clientq, client_q));
 }
 
 void
-client_delete(struct client_ctx *cc)
+client_remove(struct client_ctx *cc)
 {
 	struct screen_ctx	*sc = cc->sc;
 	struct winname		*wn;
@@ -179,27 +219,21 @@ client_delete(struct client_ctx *cc)
 	if (cc->flags & CLIENT_ACTIVE)
 		xu_ewmh_net_active_window(sc, None);
 
-	if (cc->gc != NULL)
-		TAILQ_REMOVE(&cc->gc->clientq, cc, group_entry);
-
 	while ((wn = TAILQ_FIRST(&cc->nameq)) != NULL) {
 		TAILQ_REMOVE(&cc->nameq, wn, entry);
 		free(wn->name);
 		free(wn);
 	}
 
-	if (cc->ch.res_class)
-		XFree(cc->ch.res_class);
-	if (cc->ch.res_name)
-		XFree(cc->ch.res_name);
-	if (cc->wmh)
-		XFree(cc->wmh);
-
+	free(cc->name);
+	free(cc->label);
+	free(cc->res_class);
+	free(cc->res_name);
 	free(cc);
 }
 
 void
-client_setactive(struct client_ctx *cc)
+client_set_active(struct client_ctx *cc)
 {
 	struct screen_ctx	*sc = cc->sc;
 	struct client_ctx	*oldcc;
@@ -215,14 +249,14 @@ client_setactive(struct client_ctx *cc)
 		    RevertToPointerRoot, CurrentTime);
 	}
 	if (cc->flags & CLIENT_WM_TAKE_FOCUS)
-		client_msg(cc, cwmh[WM_TAKE_FOCUS], Last_Event_Time);
+		xu_send_clientmsg(cc->win, cwmh[WM_TAKE_FOCUS], Last_Event_Time);
 
-	if ((oldcc = client_current()) != NULL) {
+	if ((oldcc = client_current(sc)) != NULL) {
 		oldcc->flags &= ~CLIENT_ACTIVE;
 		client_draw_border(oldcc);
 	}
 
-	/* If we're in the middle of cycing, don't change the order. */
+	/* If we're in the middle of cycling, don't change the order. */
 	if (!sc->cycling)
 		client_mtf(cc);
 
@@ -233,21 +267,6 @@ client_setactive(struct client_ctx *cc)
 	xu_ewmh_net_active_window(sc, cc->win);
 }
 
-struct client_ctx *
-client_current(void)
-{
-	struct screen_ctx	*sc;
-	struct client_ctx	*cc;
-
-	TAILQ_FOREACH(sc, &Screenq, entry) {
-		TAILQ_FOREACH(cc, &sc->clientq, entry) {
-			if (cc->flags & CLIENT_ACTIVE)
-				return(cc);
-		}
-	}
-	return(NULL);
-}
-
 void
 client_toggle_freeze(struct client_ctx *cc)
 {
@@ -265,6 +284,20 @@ client_toggle_hidden(struct client_ctx *cc)
 	xu_ewmh_set_net_wm_state(cc);
 }
 
+void
+client_toggle_skip_pager(struct client_ctx *cc)
+{
+	cc->flags ^= CLIENT_SKIP_PAGER;
+	xu_ewmh_set_net_wm_state(cc);
+}
+
+void
+client_toggle_skip_taskbar(struct client_ctx *cc)
+{
+	cc->flags ^= CLIENT_SKIP_TASKBAR;
+	xu_ewmh_set_net_wm_state(cc);
+}
+
 void
 client_toggle_sticky(struct client_ctx *cc)
 {
@@ -294,7 +327,7 @@ client_toggle_fullscreen(struct client_ctx *cc)
 
 	area = screen_area(sc,
 	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_NOGAP);
+	    cc->geom.y + cc->geom.h / 2, 0);
 
 	cc->bwidth = 0;
 	cc->geom = area;
@@ -303,6 +336,7 @@ client_toggle_fullscreen(struct client_ctx *cc)
 resize:
 	client_resize(cc, 0);
 	xu_ewmh_set_net_wm_state(cc);
+	client_ptr_inbound(cc, 1);
 }
 
 void
@@ -330,14 +364,9 @@ client_toggle_maximize(struct client_ctx *cc)
 		cc->savegeom.x = cc->geom.x;
 	}
 
-	/*
-	 * pick screen that the middle of the window is on.
-	 * that's probably more fair than if just the origin of
-	 * a window is poking over a boundary
-	 */
 	area = screen_area(sc,
 	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_GAP);
+	    cc->geom.y + cc->geom.h / 2, 1);
 
 	cc->geom.x = area.x;
 	cc->geom.y = area.y;
@@ -348,6 +377,7 @@ client_toggle_maximize(struct client_ctx *cc)
 resize:
 	client_resize(cc, 0);
 	xu_ewmh_set_net_wm_state(cc);
+	client_ptr_inbound(cc, 1);
 }
 
 void
@@ -371,7 +401,7 @@ client_toggle_vmaximize(struct client_ctx *cc)
 
 	area = screen_area(sc,
 	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_GAP);
+	    cc->geom.y + cc->geom.h / 2, 1);
 
 	cc->geom.y = area.y;
 	cc->geom.h = area.h - (cc->bwidth * 2);
@@ -380,6 +410,7 @@ client_toggle_vmaximize(struct client_ctx *cc)
 resize:
 	client_resize(cc, 0);
 	xu_ewmh_set_net_wm_state(cc);
+	client_ptr_inbound(cc, 1);
 }
 
 void
@@ -403,7 +434,7 @@ client_toggle_hmaximize(struct client_ctx *cc)
 
 	area = screen_area(sc,
 	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_GAP);
+	    cc->geom.y + cc->geom.h / 2, 1);
 
 	cc->geom.x = area.x;
 	cc->geom.w = area.w - (cc->bwidth * 2);
@@ -412,6 +443,7 @@ client_toggle_hmaximize(struct client_ctx *cc)
 resize:
 	client_resize(cc, 0);
 	xu_ewmh_set_net_wm_state(cc);
+	client_ptr_inbound(cc, 1);
 }
 
 void
@@ -474,7 +506,7 @@ void
 client_ptr_inbound(struct client_ctx *cc, int getpos)
 {
 	if (getpos)
-		xu_ptr_getpos(cc->win, &cc->ptr.x, &cc->ptr.y);
+		xu_ptr_get(cc->win, &cc->ptr.x, &cc->ptr.y);
 
 	if (cc->ptr.x < 0)
 		cc->ptr.x = 0;
@@ -485,21 +517,21 @@ client_ptr_inbound(struct client_ctx *cc, int getpos)
 	else if (cc->ptr.y > cc->geom.h - 1)
 		cc->ptr.y = cc->geom.h - 1;
 
-	client_ptrwarp(cc);
+	client_ptr_warp(cc);
 }
 
 void
-client_ptrwarp(struct client_ctx *cc)
+client_ptr_warp(struct client_ctx *cc)
 {
-	xu_ptr_setpos(cc->win, cc->ptr.x, cc->ptr.y);
+	xu_ptr_set(cc->win, cc->ptr.x, cc->ptr.y);
 }
 
 void
-client_ptrsave(struct client_ctx *cc)
+client_ptr_save(struct client_ctx *cc)
 {
 	int	 x, y;
 
-	xu_ptr_getpos(cc->win, &x, &y);
+	xu_ptr_get(cc->win, &x, &y);
 	if (client_inbound(cc, x, y)) {
 		cc->ptr.x = x;
 		cc->ptr.y = y;
@@ -514,21 +546,21 @@ client_hide(struct client_ctx *cc)
 {
 	XUnmapWindow(X_Dpy, cc->win);
 
-	if (cc->flags & CLIENT_ACTIVE)
+	if (cc->flags & CLIENT_ACTIVE) {
+		cc->flags &= ~CLIENT_ACTIVE;
 		xu_ewmh_net_active_window(cc->sc, None);
-
-	cc->flags &= ~CLIENT_ACTIVE;
+	}
 	cc->flags |= CLIENT_HIDDEN;
-	client_set_wm_state(cc, IconicState);
+	xu_set_wm_state(cc->win, IconicState);
 }
 
 void
-client_unhide(struct client_ctx *cc)
+client_show(struct client_ctx *cc)
 {
 	XMapRaised(X_Dpy, cc->win);
 
 	cc->flags &= ~CLIENT_HIDDEN;
-	client_set_wm_state(cc, NormalState);
+	xu_set_wm_state(cc->win, NormalState);
 	client_draw_border(cc);
 }
 
@@ -564,7 +596,24 @@ client_draw_border(struct client_ctx *cc)
 		pixel = sc->xftcolor[CWM_COLOR_BORDER_URGENCY].pixel;
 
 	XSetWindowBorderWidth(X_Dpy, cc->win, (unsigned int)cc->bwidth);
-	XSetWindowBorder(X_Dpy, cc->win, pixel);
+	XSetWindowBorder(X_Dpy, cc->win, pixel | (0xffu << 24));
+}
+
+static void
+client_class_hint(struct client_ctx *cc)
+{
+	XClassHint	ch;
+
+	if (XGetClassHint(X_Dpy, cc->win, &ch)) {
+		if (ch.res_class) {
+			cc->res_class = xstrdup(ch.res_class);
+			XFree(ch.res_class);
+		}
+		if (ch.res_name) {
+			cc->res_name = xstrdup(ch.res_name);
+			XFree(ch.res_name);
+		}
+	}
 }
 
 static void
@@ -587,221 +636,109 @@ client_wm_protocols(struct client_ctx *cc)
 void
 client_wm_hints(struct client_ctx *cc)
 {
-	if ((cc->wmh = XGetWMHints(X_Dpy, cc->win)) == NULL)
-		return;
+	XWMHints	*wmh;
 
-	if ((cc->wmh->flags & InputHint) && (cc->wmh->input))
-		cc->flags |= CLIENT_INPUT;
-
-	if ((cc->wmh->flags & XUrgencyHint))
-		client_urgency(cc);
+	if ((wmh = XGetWMHints(X_Dpy, cc->win)) != NULL) {
+		if ((wmh->flags & InputHint) && (wmh->input))
+			cc->flags |= CLIENT_INPUT;
+		if ((wmh->flags & XUrgencyHint))
+			client_urgency(cc);
+		if ((wmh->flags & StateHint))
+			cc->initial_state = wmh->initial_state;
+		XFree(wmh);
+	}
 }
 
 void
-client_msg(struct client_ctx *cc, Atom proto, Time ts)
-{
-	XClientMessageEvent	 cm;
-
-	(void)memset(&cm, 0, sizeof(cm));
-	cm.type = ClientMessage;
-	cm.window = cc->win;
-	cm.message_type = cwmh[WM_PROTOCOLS];
-	cm.format = 32;
-	cm.data.l[0] = proto;
-	cm.data.l[1] = ts;
-
-	XSendEvent(X_Dpy, cc->win, False, NoEventMask, (XEvent *)&cm);
-}
-
-void
-client_send_delete(struct client_ctx *cc)
+client_close(struct client_ctx *cc)
 {
 	if (cc->flags & CLIENT_WM_DELETE_WINDOW)
-		client_msg(cc, cwmh[WM_DELETE_WINDOW], CurrentTime);
+		xu_send_clientmsg(cc->win, cwmh[WM_DELETE_WINDOW], CurrentTime);
 	else
 		XKillClient(X_Dpy, cc->win);
 }
 
 void
-client_setname(struct client_ctx *cc)
+client_set_name(struct client_ctx *cc)
 {
-	struct winname	*wn;
-	char		*newname;
+	struct winname	*wn, *wnnxt;
 	int		 i = 0;
 
-	if (!xu_getstrprop(cc->win, ewmh[_NET_WM_NAME], &newname))
-		if (!xu_getstrprop(cc->win, XA_WM_NAME, &newname))
-			newname = xstrdup("");
+	free(cc->name);
+	if (!xu_get_strprop(cc->win, ewmh[_NET_WM_NAME], &cc->name))
+		if (!xu_get_strprop(cc->win, XA_WM_NAME, &cc->name))
+			cc->name = xstrdup("");
 
-	TAILQ_FOREACH(wn, &cc->nameq, entry) {
-		if (strcmp(wn->name, newname) == 0) {
-			/* Move to the last since we got a hit. */
+	TAILQ_FOREACH_SAFE(wn, &cc->nameq, entry, wnnxt) {
+		if (strcmp(wn->name, cc->name) == 0) {
 			TAILQ_REMOVE(&cc->nameq, wn, entry);
-			TAILQ_INSERT_TAIL(&cc->nameq, wn, entry);
-			goto match;
+			free(wn->name);
+			free(wn);
 		}
+		i++;
 	}
 	wn = xmalloc(sizeof(*wn));
-	wn->name = newname;
+	wn->name = xstrdup(cc->name);
 	TAILQ_INSERT_TAIL(&cc->nameq, wn, entry);
 
-match:
-	cc->name = wn->name;
-
-	/* Do some garbage collection. */
-	TAILQ_FOREACH(wn, &cc->nameq, entry)
-		i++;
-	if (i > Conf.nameqlen) {
+	/* Garbage collection. */
+	if ((i + 1) > Conf.nameqlen) {
 		wn = TAILQ_FIRST(&cc->nameq);
 		TAILQ_REMOVE(&cc->nameq, wn, entry);
 		free(wn->name);
 		free(wn);
-		i--;
 	}
 }
 
-void
-client_cycle(struct screen_ctx *sc, int flags)
-{
-	struct client_ctx	*newcc, *oldcc, *prevcc;
-	int			 again = 1;
-
-	/* For X apps that ignore events. */
-	XGrabKeyboard(X_Dpy, sc->rootwin, True,
-	    GrabModeAsync, GrabModeAsync, CurrentTime);
-
-	if (TAILQ_EMPTY(&sc->clientq))
-		return;
-
-	prevcc = TAILQ_FIRST(&sc->clientq);
-	oldcc = client_current();
-	if (oldcc == NULL)
-		oldcc = (flags & CWM_CYCLE_REVERSE) ?
-		    TAILQ_LAST(&sc->clientq, client_q) :
-		    TAILQ_FIRST(&sc->clientq);
-
-	newcc = oldcc;
-	while (again) {
-		again = 0;
-
-		newcc = (flags & CWM_CYCLE_REVERSE) ? client_prev(newcc) :
-		    client_next(newcc);
-
-		/* Only cycle visible and non-ignored windows. */
-		if ((newcc->flags & (CLIENT_HIDDEN | CLIENT_IGNORE))
-		    || ((flags & CWM_CYCLE_INGROUP) &&
-			(newcc->gc != oldcc->gc)))
-			again = 1;
-
-		/* Is oldcc the only non-hidden window? */
-		if (newcc == oldcc) {
-			if (again)
-				return;	/* No windows visible. */
-
-			break;
-		}
-	}
-
-	/* reset when cycling mod is released. XXX I hate this hack */
-	sc->cycling = 1;
-	client_ptrsave(oldcc);
-	client_raise(prevcc);
-	client_raise(newcc);
-	if (!client_inbound(newcc, newcc->ptr.x, newcc->ptr.y)) {
-		newcc->ptr.x = newcc->geom.w / 2;
-		newcc->ptr.y = newcc->geom.h / 2;
-	}
-	client_ptrwarp(newcc);
-}
-
-void
-client_cycle_leave(struct screen_ctx *sc)
-{
-	struct client_ctx	*cc;
-
-	sc->cycling = 0;
-
-	if ((cc = client_current()) != NULL) {
-		client_mtf(cc);
-		cc->flags &= ~CLIENT_HIGHLIGHT;
-		client_draw_border(cc);
-		XUngrabKeyboard(X_Dpy, CurrentTime);
-	}
-}
-
-static struct client_ctx *
-client_next(struct client_ctx *cc)
-{
-	struct screen_ctx	*sc = cc->sc;
-	struct client_ctx	*newcc;
-
-	return(((newcc = TAILQ_NEXT(cc, entry)) != NULL) ?
-	    newcc : TAILQ_FIRST(&sc->clientq));
-}
-
-static struct client_ctx *
-client_prev(struct client_ctx *cc)
-{
-	struct screen_ctx	*sc = cc->sc;
-	struct client_ctx	*newcc;
-
-	return(((newcc = TAILQ_PREV(cc, client_q, entry)) != NULL) ?
-	    newcc : TAILQ_LAST(&sc->clientq, client_q));
-}
-
 static void
-client_placecalc(struct client_ctx *cc)
+client_placement(struct client_ctx *cc)
 {
 	struct screen_ctx	*sc = cc->sc;
-	int			 xslack, yslack;
 
 	if (cc->hint.flags & (USPosition | PPosition)) {
-		int			 wmax, hmax;
-
-		wmax = DisplayWidth(X_Dpy, sc->which);
-		hmax = DisplayHeight(X_Dpy, sc->which);
-
-		if (cc->geom.x >= wmax)
-			cc->geom.x = wmax - cc->bwidth - 1;
+		if (cc->geom.x >= sc->view.w)
+			cc->geom.x = sc->view.w - cc->bwidth - 1;
 		if (cc->geom.x + cc->geom.w + cc->bwidth <= 0)
 			cc->geom.x = -(cc->geom.w + cc->bwidth - 1);
-		if (cc->geom.y >= hmax)
-			cc->geom.x = hmax - cc->bwidth - 1;
+		if (cc->geom.y >= sc->view.h)
+			cc->geom.x = sc->view.h - cc->bwidth - 1;
 		if (cc->geom.y + cc->geom.h + cc->bwidth <= 0)
 			cc->geom.y = -(cc->geom.h + cc->bwidth - 1);
+		if (cc->flags & CLIENT_IGNORE) {
+			if (((cc->obwidth * 2) + cc->geom.x + cc->geom.w) == sc->view.w)
+				cc->geom.x += cc->obwidth * 2;
+			if (((cc->obwidth * 2) + cc->geom.y + cc->geom.h) == sc->view.h)
+				cc->geom.y += cc->obwidth * 2;
+		}
 	} else {
-		struct geom		 area;
-		int			 xmouse, ymouse;
+		struct geom	 area;
+		int		 xmouse, ymouse, xslack, yslack;
 
-		xu_ptr_getpos(sc->rootwin, &xmouse, &ymouse);
-		area = screen_area(sc, xmouse, ymouse, CWM_GAP);
-		area.w += area.x;
-		area.h += area.y;
-		xmouse = MAX(xmouse, area.x) - cc->geom.w / 2;
-		ymouse = MAX(ymouse, area.y) - cc->geom.h / 2;
+		xu_ptr_get(sc->rootwin, &xmouse, &ymouse);
+		area = screen_area(sc, xmouse, ymouse, 1);
 
-		xmouse = MAX(xmouse, area.x);
-		ymouse = MAX(ymouse, area.y);
+		xmouse = MAX(MAX(xmouse, area.x) - cc->geom.w / 2, area.x);
+		ymouse = MAX(MAX(ymouse, area.y) - cc->geom.h / 2, area.y);
 
-		xslack = area.w - cc->geom.w - cc->bwidth * 2;
-		yslack = area.h - cc->geom.h - cc->bwidth * 2;
+		xslack = area.x + area.w - cc->geom.w - cc->bwidth * 2;
+		yslack = area.y + area.h - cc->geom.h - cc->bwidth * 2;
 
 		if (xslack >= area.x) {
 			cc->geom.x = MAX(MIN(xmouse, xslack), area.x);
 		} else {
 			cc->geom.x = area.x;
-			cc->geom.w = area.w;
+			cc->geom.w = area.x + area.w;
 		}
 		if (yslack >= area.y) {
 			cc->geom.y = MAX(MIN(ymouse, yslack), area.y);
 		} else {
 			cc->geom.y = area.y;
-			cc->geom.h = area.h;
+			cc->geom.h = area.y + area.h;
 		}
 	}
 }
 
-static void
+void
 client_mtf(struct client_ctx *cc)
 {
 	struct screen_ctx	*sc = cc->sc;
@@ -811,7 +748,7 @@ client_mtf(struct client_ctx *cc)
 }
 
 void
-client_getsizehints(struct client_ctx *cc)
+client_get_sizehints(struct client_ctx *cc)
 {
 	long		 tmp;
 	XSizeHints	 size;
@@ -859,7 +796,7 @@ client_getsizehints(struct client_ctx *cc)
 }
 
 void
-client_applysizehints(struct client_ctx *cc)
+client_apply_sizehints(struct client_ctx *cc)
 {
 	Bool		 baseismin;
 
@@ -910,14 +847,17 @@ client_mwm_hints(struct client_ctx *cc)
 {
 	struct mwm_hints	*mwmh;
 
-	if (xu_getprop(cc->win, cwmh[_MOTIF_WM_HINTS], cwmh[_MOTIF_WM_HINTS],
-	    MWM_HINTS_ELEMENTS, (unsigned char **)&mwmh) == MWM_HINTS_ELEMENTS) {
-		if (mwmh->flags & MWM_FLAGS_DECORATIONS &&
-		    !(mwmh->decorations & MWM_DECOR_ALL) &&
-		    !(mwmh->decorations & MWM_DECOR_BORDER))
+	if (xu_get_prop(cc->win, cwmh[_MOTIF_WM_HINTS],
+	    cwmh[_MOTIF_WM_HINTS], MWM_HINTS_ELEMENTS,
+	    (unsigned char **)&mwmh) <= 0)
+		return;
+
+	if ((mwmh->flags & MWM_HINTS_DECORATIONS) &&
+	    !(mwmh->decorations & MWM_DECOR_ALL)) {
+		if (!(mwmh->decorations & MWM_DECOR_BORDER))
 			cc->bwidth = 0;
-		XFree(mwmh);
 	}
+	XFree(mwmh);
 }
 
 void
@@ -927,10 +867,11 @@ client_transient(struct client_ctx *cc)
 	Window			 trans;
 
 	if (XGetTransientForHint(X_Dpy, cc->win, &trans)) {
-		if ((tc = client_find(trans)) != NULL && tc->gc) {
-			group_movetogroup(cc, tc->gc->num);
-			if (tc->flags & CLIENT_IGNORE)
+		if ((tc = client_find(trans)) != NULL) {
+			if (tc->flags & CLIENT_IGNORE) {
 				cc->flags |= CLIENT_IGNORE;
+				cc->bwidth = tc->bwidth;
+			}
 		}
 	}
 }
@@ -958,43 +899,45 @@ client_snapcalc(int n0, int n1, int e0, int e1, int snapdist)
 	/* possible to snap in both directions */
 	if (s0 != 0 && s1 != 0)
 		if (abs(s0) < abs(s1))
-			return(s0);
+			return s0;
 		else
-			return(s1);
+			return s1;
 	else if (s0 != 0)
-		return(s0);
+		return s0;
 	else if (s1 != 0)
-		return(s1);
+		return s1;
 	else
-		return(0);
+		return 0;
 }
 
 void
 client_htile(struct client_ctx *cc)
 {
 	struct client_ctx	*ci;
-	struct group_ctx 	*gc = cc->gc;
 	struct screen_ctx 	*sc = cc->sc;
 	struct geom 		 area;
 	int 			 i, n, mh, x, w, h;
 
-	if (!gc)
-		return;
 	i = n = 0;
+	area = screen_area(sc,
+	    cc->geom.x + cc->geom.w / 2,
+	    cc->geom.y + cc->geom.h / 2, 1);
 
-	TAILQ_FOREACH(ci, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(ci, &sc->clientq, entry) {
+		if (ci->gc != cc->gc)
+			continue;
 		if (ci->flags & CLIENT_HIDDEN ||
-		    ci->flags & CLIENT_IGNORE || (ci == cc))
+		    ci->flags & CLIENT_IGNORE || (ci == cc) ||
+		    ci->geom.x < area.x ||
+		    ci->geom.x > (area.x + area.w) ||
+		    ci->geom.y < area.y ||
+		    ci->geom.y > (area.y + area.h))
 			continue;
 		n++;
 	}
 	if (n == 0)
 		return;
 
-	area = screen_area(sc,
-	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_GAP);
-
 	if (cc->flags & CLIENT_VMAXIMIZED ||
 	    cc->geom.h + (cc->bwidth * 2) >= area.h)
 		return;
@@ -1003,17 +946,24 @@ client_htile(struct client_ctx *cc)
 	cc->geom.x = area.x;
 	cc->geom.y = area.y;
 	cc->geom.w = area.w - (cc->bwidth * 2);
-	cc->geom.h = (area.h - (cc->bwidth * 2)) / 2;
+	if (Conf.htile > 0)
+		cc->geom.h = ((area.h - (cc->bwidth * 2)) * Conf.htile) / 100;
 	client_resize(cc, 1);
-	client_ptrwarp(cc);
+	client_ptr_warp(cc);
 
 	mh = cc->geom.h + (cc->bwidth * 2);
 	x = area.x;
 	w = area.w / n;
 	h = area.h - mh;
-	TAILQ_FOREACH(ci, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(ci, &sc->clientq, entry) {
+		if (ci->gc != cc->gc)
+			continue;
 		if (ci->flags & CLIENT_HIDDEN ||
-		    ci->flags & CLIENT_IGNORE || (ci == cc))
+		    ci->flags & CLIENT_IGNORE || (ci == cc) ||
+		    ci->geom.x < area.x ||
+		    ci->geom.x > (area.x + area.w) ||
+		    ci->geom.y < area.y ||
+		    ci->geom.y > (area.y + area.h))
 			continue;
 		ci->bwidth = Conf.bwidth;
 		ci->geom.x = x;
@@ -1033,28 +983,30 @@ void
 client_vtile(struct client_ctx *cc)
 {
 	struct client_ctx	*ci;
-	struct group_ctx 	*gc = cc->gc;
 	struct screen_ctx 	*sc = cc->sc;
 	struct geom 		 area;
 	int 			 i, n, mw, y, w, h;
 
-	if (!gc)
-		return;
 	i = n = 0;
+	area = screen_area(sc,
+	    cc->geom.x + cc->geom.w / 2,
+	    cc->geom.y + cc->geom.h / 2, 1);
 
-	TAILQ_FOREACH(ci, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(ci, &sc->clientq, entry) {
+		if (ci->gc != cc->gc)
+			continue;
 		if (ci->flags & CLIENT_HIDDEN ||
-		    ci->flags & CLIENT_IGNORE || (ci == cc))
+		    ci->flags & CLIENT_IGNORE || (ci == cc) ||
+		    ci->geom.x < area.x ||
+		    ci->geom.x > (area.x + area.w) ||
+		    ci->geom.y < area.y ||
+		    ci->geom.y > (area.y + area.h))
 			continue;
 		n++;
 	}
 	if (n == 0)
 		return;
 
-	area = screen_area(sc,
-	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_GAP);
-
 	if (cc->flags & CLIENT_HMAXIMIZED ||
 	    cc->geom.w + (cc->bwidth * 2) >= area.w)
 		return;
@@ -1062,18 +1014,25 @@ client_vtile(struct client_ctx *cc)
 	cc->flags &= ~CLIENT_VMAXIMIZED;
 	cc->geom.x = area.x;
 	cc->geom.y = area.y;
-	cc->geom.w = (area.w - (cc->bwidth * 2)) / 2;
+	if (Conf.vtile > 0)
+		cc->geom.w = ((area.w - (cc->bwidth * 2)) * Conf.vtile) / 100;
 	cc->geom.h = area.h - (cc->bwidth * 2);
 	client_resize(cc, 1);
-	client_ptrwarp(cc);
+	client_ptr_warp(cc);
 
 	mw = cc->geom.w + (cc->bwidth * 2);
 	y = area.y;
 	h = area.h / n;
 	w = area.w - mw;
-	TAILQ_FOREACH(ci, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(ci, &sc->clientq, entry) {
+		if (ci->gc != cc->gc)
+			continue;
 		if (ci->flags & CLIENT_HIDDEN ||
-		    ci->flags & CLIENT_IGNORE || (ci == cc))
+		    ci->flags & CLIENT_IGNORE || (ci == cc) ||
+		    ci->geom.x < area.x ||
+		    ci->geom.x > (area.x + area.w) ||
+		    ci->geom.y < area.y ||
+		    ci->geom.y > (area.y + area.h))
 			continue;
 		ci->bwidth = Conf.bwidth;
 		ci->geom.x = area.x + mw;
@@ -1088,25 +1047,3 @@ client_vtile(struct client_ctx *cc)
 		client_resize(ci, 1);
 	}
 }
-
-long
-client_get_wm_state(struct client_ctx *cc)
-{
-	long	*p, state = -1;
-
-	if (xu_getprop(cc->win, cwmh[WM_STATE], cwmh[WM_STATE], 2L,
-	    (unsigned char **)&p) > 0) {
-		state = *p;
-		XFree(p);
-	}
-	return(state);
-}
-
-void
-client_set_wm_state(struct client_ctx *cc, long state)
-{
-	long	 data[] = { state, None };
-
-	XChangeProperty(X_Dpy, cc->win, cwmh[WM_STATE], cwmh[WM_STATE], 32,
-	    PropModeReplace, (unsigned char *)data, 2);
-}

conf.c

@@ -20,11 +20,11 @@
 
 #include <sys/types.h>
 #include "queue.h"
-#include <sys/stat.h>
 
 #include <err.h>
 #include <errno.h>
 #include <limits.h>
+#include <pwd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -32,11 +32,25 @@
 
 #include "calmwm.h"
 
-static const char	*conf_bind_getmask(const char *, unsigned int *);
-static void		 conf_cmd_remove(struct conf *, const char *);
+static const char	*conf_bind_mask(const char *, unsigned int *);
 static void		 conf_unbind_key(struct conf *, struct bind_ctx *);
 static void		 conf_unbind_mouse(struct conf *, struct bind_ctx *);
 
+static const struct {
+	int		 num;
+	const char	*name;
+} group_binds[] = {
+	{ 0, "nogroup" },
+	{ 1, "one" },
+	{ 2, "two" },
+	{ 3, "three" },
+	{ 4, "four" },
+	{ 5, "five" },
+	{ 6, "six" },
+	{ 7, "seven" },
+	{ 8, "eight" },
+	{ 9, "nine" },
+};
 static int cursor_binds[] = {
 	XC_left_ptr,		/* CF_NORMAL */
 	XC_fleur,		/* CF_MOVE */
@@ -60,131 +74,122 @@ static const struct {
 	enum context	 context;
 	int		 flag;
 } name_to_func[] = {
-	{ "window-menu-label", kbfunc_client_menu_label, CWM_CONTEXT_CC, 0 },
-	{ "window-lower", kbfunc_client_lower, CWM_CONTEXT_CC, 0 },
-	{ "window-raise", kbfunc_client_raise, CWM_CONTEXT_CC, 0 },
-	{ "window-hide", kbfunc_client_hide, CWM_CONTEXT_CC, 0 },
-	{ "window-delete", kbfunc_client_delete, CWM_CONTEXT_CC, 0 },
-	{ "window-htile", kbfunc_client_htile, CWM_CONTEXT_CC, 0 },
-	{ "window-vtile", kbfunc_client_vtile, CWM_CONTEXT_CC, 0 },
-	{ "window-stick", kbfunc_client_toggle_sticky, CWM_CONTEXT_CC, 0 },
-	{ "window-fullscreen", kbfunc_client_toggle_fullscreen, CWM_CONTEXT_CC, 0 },
-	{ "window-maximize", kbfunc_client_toggle_maximize, CWM_CONTEXT_CC, 0 },
-	{ "window-vmaximize", kbfunc_client_toggle_vmaximize, CWM_CONTEXT_CC, 0 },
-	{ "window-hmaximize", kbfunc_client_toggle_hmaximize, CWM_CONTEXT_CC, 0 },
-	{ "window-freeze", kbfunc_client_toggle_freeze, CWM_CONTEXT_CC, 0 },
-	{ "window-cycle", kbfunc_client_cycle, CWM_CONTEXT_SC,
-	    (CWM_CYCLE_FORWARD) },
-	{ "window-rcycle", kbfunc_client_cycle, CWM_CONTEXT_SC,
-	    (CWM_CYCLE_REVERSE) },
-	{ "window-cycle-ingroup", kbfunc_client_cycle, CWM_CONTEXT_SC,
-	    (CWM_CYCLE_FORWARD | CWM_CYCLE_INGROUP) },
-	{ "window-rcycle-ingroup", kbfunc_client_cycle, CWM_CONTEXT_SC,
-	    (CWM_CYCLE_REVERSE | CWM_CYCLE_INGROUP) },
-	{ "window-group", kbfunc_client_toggle_group, CWM_CONTEXT_CC, 0 },
-	{ "window-movetogroup-1", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 1 },
-	{ "window-movetogroup-2", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 2 },
-	{ "window-movetogroup-3", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 3 },
-	{ "window-movetogroup-4", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 4 },
-	{ "window-movetogroup-5", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 5 },
-	{ "window-movetogroup-6", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 6 },
-	{ "window-movetogroup-7", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 7 },
-	{ "window-movetogroup-8", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 8 },
-	{ "window-movetogroup-9", kbfunc_client_movetogroup, CWM_CONTEXT_CC, 9 },
+#define FUNC_CC(t, h, n) \
+	#t, kbfunc_ ## h, CWM_CONTEXT_CC, n
+#define FUNC_SC(t, h, n) \
+	#t, kbfunc_ ## h, CWM_CONTEXT_SC, n
 
-	{ "window-move", kbfunc_client_move, CWM_CONTEXT_CC, 0 },
-	{ "window-move-up", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_UP) },
-	{ "window-move-down", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_DOWN) },
-	{ "window-move-right", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_RIGHT) },
-	{ "window-move-left", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_LEFT) },
-	{ "window-move-up-big", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_UP | CWM_BIGAMOUNT) },
-	{ "window-move-down-big", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_DOWN | CWM_BIGAMOUNT) },
-	{ "window-move-right-big", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_RIGHT | CWM_BIGAMOUNT) },
-	{ "window-move-left-big", kbfunc_client_move, CWM_CONTEXT_CC,
-	    (CWM_LEFT | CWM_BIGAMOUNT) },
-	{ "window-resize", kbfunc_client_resize, CWM_CONTEXT_CC, 0 },
-	{ "window-resize-up", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_UP) },
-	{ "window-resize-down", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_DOWN) },
-	{ "window-resize-right", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_RIGHT) },
-	{ "window-resize-left", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_LEFT) },
-	{ "window-resize-up-big", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_UP | CWM_BIGAMOUNT) },
-	{ "window-resize-down-big", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_DOWN | CWM_BIGAMOUNT) },
-	{ "window-resize-right-big", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_RIGHT | CWM_BIGAMOUNT) },
-	{ "window-resize-left-big", kbfunc_client_resize, CWM_CONTEXT_CC,
-	    (CWM_LEFT | CWM_BIGAMOUNT) },
+	{ FUNC_CC(window-lower, client_lower, 0) },
+	{ FUNC_CC(window-raise, client_raise, 0) },
+	{ FUNC_CC(window-hide, client_hide, 0) },
+	{ FUNC_CC(window-close, client_close, 0) },
+	{ FUNC_CC(window-delete, client_close, 0) },
+	{ FUNC_CC(window-htile, client_htile, 0) },
+	{ FUNC_CC(window-vtile, client_vtile, 0) },
+	{ FUNC_CC(window-stick, client_toggle_sticky, 0) },
+	{ FUNC_CC(window-fullscreen, client_toggle_fullscreen, 0) },
+	{ FUNC_CC(window-maximize, client_toggle_maximize, 0) },
+	{ FUNC_CC(window-vmaximize, client_toggle_vmaximize, 0) },
+	{ FUNC_CC(window-hmaximize, client_toggle_hmaximize, 0) },
+	{ FUNC_CC(window-freeze, client_toggle_freeze, 0) },
+	{ FUNC_CC(window-group, client_toggle_group, 0) },
+	{ FUNC_CC(window-movetogroup-1, client_movetogroup, 1) },
+	{ FUNC_CC(window-movetogroup-2, client_movetogroup, 2) },
+	{ FUNC_CC(window-movetogroup-3, client_movetogroup, 3) },
+	{ FUNC_CC(window-movetogroup-4, client_movetogroup, 4) },
+	{ FUNC_CC(window-movetogroup-5, client_movetogroup, 5) },
+	{ FUNC_CC(window-movetogroup-6, client_movetogroup, 6) },
+	{ FUNC_CC(window-movetogroup-7, client_movetogroup, 7) },
+	{ FUNC_CC(window-movetogroup-8, client_movetogroup, 8) },
+	{ FUNC_CC(window-movetogroup-9, client_movetogroup, 9) },
+	{ FUNC_CC(window-snap-up, client_snap, (CWM_UP)) },
+	{ FUNC_CC(window-snap-down, client_snap, (CWM_DOWN)) },
+	{ FUNC_CC(window-snap-right, client_snap, (CWM_RIGHT)) },
+	{ FUNC_CC(window-snap-left, client_snap, (CWM_LEFT)) },
+	{ FUNC_CC(window-snap-up-right, client_snap, (CWM_UP_RIGHT)) },
+	{ FUNC_CC(window-snap-up-left, client_snap, (CWM_UP_LEFT)) },
+	{ FUNC_CC(window-snap-down-right, client_snap, (CWM_DOWN_RIGHT)) },
+	{ FUNC_CC(window-snap-down-left, client_snap, (CWM_DOWN_LEFT)) },
+	{ FUNC_CC(window-move, client_move, 0) },
+	{ FUNC_CC(window-move-up, client_move, (CWM_UP)) },
+	{ FUNC_CC(window-move-down, client_move, (CWM_DOWN)) },
+	{ FUNC_CC(window-move-right, client_move, (CWM_RIGHT)) },
+	{ FUNC_CC(window-move-left, client_move, (CWM_LEFT)) },
+	{ FUNC_CC(window-move-up-big, client_move, (CWM_UP_BIG)) },
+	{ FUNC_CC(window-move-down-big, client_move, (CWM_DOWN_BIG)) },
+	{ FUNC_CC(window-move-right-big, client_move, (CWM_RIGHT_BIG)) },
+	{ FUNC_CC(window-move-left-big, client_move, (CWM_LEFT_BIG)) },
+	{ FUNC_CC(window-resize, client_resize, 0) },
+	{ FUNC_CC(window-resize-up, client_resize, (CWM_UP)) },
+	{ FUNC_CC(window-resize-down, client_resize, (CWM_DOWN)) },
+	{ FUNC_CC(window-resize-right, client_resize, (CWM_RIGHT)) },
+	{ FUNC_CC(window-resize-left, client_resize, (CWM_LEFT)) },
+	{ FUNC_CC(window-resize-up-big, client_resize, (CWM_UP_BIG)) },
+	{ FUNC_CC(window-resize-down-big, client_resize, (CWM_DOWN_BIG)) },
+	{ FUNC_CC(window-resize-right-big, client_resize, (CWM_RIGHT_BIG)) },
+	{ FUNC_CC(window-resize-left-big, client_resize, (CWM_LEFT_BIG)) },
+	{ FUNC_CC(window-menu-label, client_menu_label, 0) },
 
-	{ "group-cycle", kbfunc_group_cycle, CWM_CONTEXT_SC,
-	    (CWM_CYCLE_FORWARD) },
-	{ "group-rcycle", kbfunc_group_cycle, CWM_CONTEXT_SC,
-	    (CWM_CYCLE_REVERSE) },
-	{ "group-toggle-all", kbfunc_group_alltoggle, CWM_CONTEXT_SC, 0 },
-	{ "group-toggle-1", kbfunc_group_toggle, CWM_CONTEXT_SC, 1 },
-	{ "group-toggle-2", kbfunc_group_toggle, CWM_CONTEXT_SC, 2 },
-	{ "group-toggle-3", kbfunc_group_toggle, CWM_CONTEXT_SC, 3 },
-	{ "group-toggle-4", kbfunc_group_toggle, CWM_CONTEXT_SC, 4 },
-	{ "group-toggle-5", kbfunc_group_toggle, CWM_CONTEXT_SC, 5 },
-	{ "group-toggle-6", kbfunc_group_toggle, CWM_CONTEXT_SC, 6 },
-	{ "group-toggle-7", kbfunc_group_toggle, CWM_CONTEXT_SC, 7 },
-	{ "group-toggle-8", kbfunc_group_toggle, CWM_CONTEXT_SC, 8 },
-	{ "group-toggle-9", kbfunc_group_toggle, CWM_CONTEXT_SC, 9 },
-	{ "group-only-1", kbfunc_group_only, CWM_CONTEXT_SC, 1 },
-	{ "group-only-2", kbfunc_group_only, CWM_CONTEXT_SC, 2 },
-	{ "group-only-3", kbfunc_group_only, CWM_CONTEXT_SC, 3 },
-	{ "group-only-4", kbfunc_group_only, CWM_CONTEXT_SC, 4 },
-	{ "group-only-5", kbfunc_group_only, CWM_CONTEXT_SC, 5 },
-	{ "group-only-6", kbfunc_group_only, CWM_CONTEXT_SC, 6 },
-	{ "group-only-7", kbfunc_group_only, CWM_CONTEXT_SC, 7 },
-	{ "group-only-8", kbfunc_group_only, CWM_CONTEXT_SC, 8 },
-	{ "group-only-9", kbfunc_group_only, CWM_CONTEXT_SC, 9 },
+	{ FUNC_SC(window-cycle, client_cycle, (CWM_CYCLE_FORWARD)) },
+	{ FUNC_SC(window-rcycle, client_cycle, (CWM_CYCLE_REVERSE)) },
+	{ FUNC_SC(window-cycle-ingroup, client_cycle,
+		(CWM_CYCLE_FORWARD | CWM_CYCLE_INGROUP)) },
+	{ FUNC_SC(window-rcycle-ingroup, client_cycle,
+		(CWM_CYCLE_REVERSE | CWM_CYCLE_INGROUP)) },
 
-	{ "pointer-move-up", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_UP) },
-	{ "pointer-move-down", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_DOWN) },
-	{ "pointer-move-left", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_LEFT) },
-	{ "pointer-move-right", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_RIGHT) },
-	{ "pointer-move-up-big", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_UP | CWM_BIGAMOUNT) },
-	{ "pointer-move-down-big", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_DOWN | CWM_BIGAMOUNT) },
-	{ "pointer-move-left-big", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_LEFT | CWM_BIGAMOUNT) },
-	{ "pointer-move-right-big", kbfunc_ptrmove, CWM_CONTEXT_SC,
-	    (CWM_RIGHT | CWM_BIGAMOUNT) },
+	{ FUNC_SC(group-cycle, group_cycle, (CWM_CYCLE_FORWARD)) },
+	{ FUNC_SC(group-rcycle, group_cycle, (CWM_CYCLE_REVERSE)) },
+	{ FUNC_SC(group-last, group_last, 0) },
+	{ FUNC_SC(group-toggle-all, group_toggle_all, 0) },
+	{ FUNC_SC(group-toggle-1, group_toggle, 1) },
+	{ FUNC_SC(group-toggle-2, group_toggle, 2) },
+	{ FUNC_SC(group-toggle-3, group_toggle, 3) },
+	{ FUNC_SC(group-toggle-4, group_toggle, 4) },
+	{ FUNC_SC(group-toggle-5, group_toggle, 5) },
+	{ FUNC_SC(group-toggle-6, group_toggle, 6) },
+	{ FUNC_SC(group-toggle-7, group_toggle, 7) },
+	{ FUNC_SC(group-toggle-8, group_toggle, 8) },
+	{ FUNC_SC(group-toggle-9, group_toggle, 9) },
+	{ FUNC_SC(group-only-1, group_only, 1) },
+	{ FUNC_SC(group-only-2, group_only, 2) },
+	{ FUNC_SC(group-only-3, group_only, 3) },
+	{ FUNC_SC(group-only-4, group_only, 4) },
+	{ FUNC_SC(group-only-5, group_only, 5) },
+	{ FUNC_SC(group-only-6, group_only, 6) },
+	{ FUNC_SC(group-only-7, group_only, 7) },
+	{ FUNC_SC(group-only-8, group_only, 8) },
+	{ FUNC_SC(group-only-9, group_only, 9) },
+	{ FUNC_SC(group-close-1, group_close, 1) },
+	{ FUNC_SC(group-close-2, group_close, 2) },
+	{ FUNC_SC(group-close-3, group_close, 3) },
+	{ FUNC_SC(group-close-4, group_close, 4) },
+	{ FUNC_SC(group-close-5, group_close, 5) },
+	{ FUNC_SC(group-close-6, group_close, 6) },
+	{ FUNC_SC(group-close-7, group_close, 7) },
+	{ FUNC_SC(group-close-8, group_close, 8) },
+	{ FUNC_SC(group-close-9, group_close, 9) },
 
-	{ "menu-cmd", kbfunc_menu_cmd, CWM_CONTEXT_SC, 0 },
-	{ "menu-group", kbfunc_menu_group, CWM_CONTEXT_SC, 0 },
-	{ "menu-ssh", kbfunc_menu_ssh, CWM_CONTEXT_SC, 0 },
-	{ "menu-window", kbfunc_menu_client, CWM_CONTEXT_SC,
-	    CWM_MENU_WINDOW_ALL },
-	{ "menu-window-hidden", kbfunc_menu_client, CWM_CONTEXT_SC,
-	    CWM_MENU_WINDOW_HIDDEN },
-	{ "menu-exec", kbfunc_menu_exec, CWM_CONTEXT_SC,
-	    CWM_MENU_EXEC_EXEC },
-	{ "menu-exec-wm", kbfunc_menu_exec, CWM_CONTEXT_SC,
-	    CWM_MENU_EXEC_WM },
+	{ FUNC_SC(pointer-move-up, ptrmove, (CWM_UP)) },
+	{ FUNC_SC(pointer-move-down, ptrmove, (CWM_DOWN)) },
+	{ FUNC_SC(pointer-move-left, ptrmove, (CWM_LEFT)) },
+	{ FUNC_SC(pointer-move-right, ptrmove, (CWM_RIGHT)) },
+	{ FUNC_SC(pointer-move-up-big, ptrmove, (CWM_UP_BIG)) },
+	{ FUNC_SC(pointer-move-down-big, ptrmove, (CWM_DOWN_BIG)) },
+	{ FUNC_SC(pointer-move-left-big, ptrmove, (CWM_LEFT_BIG)) },
+	{ FUNC_SC(pointer-move-right-big, ptrmove, (CWM_RIGHT_BIG)) },
 
-	{ "terminal", kbfunc_exec_term, CWM_CONTEXT_SC, 0 },
-	{ "lock", kbfunc_exec_lock, CWM_CONTEXT_SC, 0 },
-	{ "restart", kbfunc_cwm_status, CWM_CONTEXT_SC, CWM_EXEC_WM },
-	{ "quit", kbfunc_cwm_status, CWM_CONTEXT_SC, CWM_QUIT },
+	{ FUNC_SC(menu-cmd, menu_cmd, 0) },
+	{ FUNC_SC(menu-group, menu_group, 0) },
+	{ FUNC_SC(menu-ssh, menu_ssh, 0) },
+	{ FUNC_SC(menu-window, menu_client, CWM_MENU_WINDOW_ALL) },
+	{ FUNC_SC(menu-window-hidden, menu_client, CWM_MENU_WINDOW_HIDDEN) },
+	{ FUNC_SC(menu-exec, menu_exec, 0) },
+	{ FUNC_SC(menu-exec-wm, menu_wm, 0) },
 
+	{ FUNC_SC(terminal, exec_term, 0) },
+	{ FUNC_SC(lock, exec_lock, 0) },
+	{ FUNC_SC(restart, cwm_status, CWM_EXEC_WM) },
+	{ FUNC_SC(quit, cwm_status, CWM_QUIT) },
 };
 static unsigned int ignore_mods[] = {
 	0, LockMask, Mod2Mask, Mod2Mask | LockMask
@@ -193,10 +198,11 @@ static const struct {
 	const char	ch;
 	int		mask;
 } bind_mods[] = {
+	{ 'S',	ShiftMask },
 	{ 'C',	ControlMask },
 	{ 'M',	Mod1Mask },
 	{ '4',	Mod4Mask },
-	{ 'S',	ShiftMask },
+	{ '5',	Mod5Mask },
 };
 static const struct {
 	const char	*key;
@@ -215,7 +221,7 @@ static const struct {
 	{ "M-Tab",	"window-cycle" },
 	{ "MS-Tab",	"window-rcycle" },
 	{ "CM-n",	"window-menu-label" },
-	{ "CM-x",	"window-delete" },
+	{ "CM-x",	"window-close" },
 	{ "CM-a",	"group-toggle-all" },
 	{ "CM-0",	"group-toggle-all" },
 	{ "CM-1",	"group-toggle-1" },
@@ -269,20 +275,25 @@ mouse_binds[] = {
 void
 conf_init(struct conf *c)
 {
+	const char	*home;
+	struct passwd	*pw;
 	unsigned int	i;
 
 	c->stickygroups = 0;
 	c->bwidth = 1;
 	c->mamount = 1;
+	c->htile = 50;
+	c->vtile = 50;
 	c->snapdist = 0;
-	c->ngroups = 10;
+	c->ngroups = 0;
 	c->nameqlen = 5;
 
 	TAILQ_INIT(&c->ignoreq);
-	TAILQ_INIT(&c->cmdq);
-	TAILQ_INIT(&c->keybindq);
 	TAILQ_INIT(&c->autogroupq);
+	TAILQ_INIT(&c->keybindq);
 	TAILQ_INIT(&c->mousebindq);
+	TAILQ_INIT(&c->cmdq);
+	TAILQ_INIT(&c->wmq);
 
 	for (i = 0; i < nitems(key_binds); i++)
 		conf_bind_key(c, key_binds[i].key, key_binds[i].func);
@@ -295,12 +306,21 @@ conf_init(struct conf *c)
 
 	conf_cmd_add(c, "lock", "xlock");
 	conf_cmd_add(c, "term", "xterm");
-
-	(void)snprintf(c->known_hosts, sizeof(c->known_hosts), "%s/%s",
-	    homedir, ".ssh/known_hosts");
+	conf_wm_add(c, "cwm", "cwm");
 
 	c->font = xstrdup("sans-serif:pixelsize=14:bold");
 	c->wmname = xstrdup("CWM");
+
+	home = getenv("HOME");
+	if ((home == NULL) || (*home == '\0')) {
+		pw = getpwuid(getuid());
+		if (pw != NULL && pw->pw_dir != NULL && *pw->pw_dir != '\0')
+			home = pw->pw_dir;
+		else
+			home = "/";
+	}
+	xasprintf(&c->conf_file, "%s/%s", home, ".cwmrc");
+	xasprintf(&c->known_hosts, "%s/%s", home, ".ssh/known_hosts");
 }
 
 void
@@ -309,14 +329,21 @@ conf_clear(struct conf *c)
 	struct autogroup	*ag;
 	struct bind_ctx		*kb, *mb;
 	struct winname		*wn;
-	struct cmd_ctx		*cmd;
+	struct cmd_ctx		*cmd, *wm;
 	int			 i;
 
 	while ((cmd = TAILQ_FIRST(&c->cmdq)) != NULL) {
 		TAILQ_REMOVE(&c->cmdq, cmd, entry);
 		free(cmd->name);
+		free(cmd->path);
 		free(cmd);
 	}
+	while ((wm = TAILQ_FIRST(&c->wmq)) != NULL) {
+		TAILQ_REMOVE(&c->wmq, wm, entry);
+		free(wm->name);
+		free(wm->path);
+		free(wm);
+	}
 	while ((kb = TAILQ_FIRST(&c->keybindq)) != NULL) {
 		TAILQ_REMOVE(&c->keybindq, kb, entry);
 		free(kb);
@@ -339,40 +366,50 @@ conf_clear(struct conf *c)
 	for (i = 0; i < CWM_COLOR_NITEMS; i++)
 		free(c->color[i]);
 
+	free(c->conf_file);
+	free(c->known_hosts);
 	free(c->font);
 	free(c->wmname);
 }
 
-int
+void
 conf_cmd_add(struct conf *c, const char *name, const char *path)
 {
-	struct cmd_ctx	*cmd;
+	struct cmd_ctx	*cmd, *cmdtmp = NULL, *cmdnxt;
 
 	cmd = xmalloc(sizeof(*cmd));
 	cmd->name = xstrdup(name);
-	if (strlcpy(cmd->path, path, sizeof(cmd->path)) >= sizeof(cmd->path)) {
-		free(cmd->name);
-		free(cmd);
-		return(0);
-	}
-	conf_cmd_remove(c, name);
+	cmd->path = xstrdup(path);
 
-	TAILQ_INSERT_TAIL(&c->cmdq, cmd, entry);
-	return(1);
-}
-
-static void
-conf_cmd_remove(struct conf *c, const char *name)
-{
-	struct cmd_ctx	*cmd = NULL, *cmdnxt;
-
-	TAILQ_FOREACH_SAFE(cmd, &c->cmdq, entry, cmdnxt) {
-		if (strcmp(cmd->name, name) == 0) {
-			TAILQ_REMOVE(&c->cmdq, cmd, entry);
-			free(cmd->name);
-			free(cmd);
+	TAILQ_FOREACH_SAFE(cmdtmp, &c->cmdq, entry, cmdnxt) {
+		if (strcmp(cmdtmp->name, name) == 0) {
+			TAILQ_REMOVE(&c->cmdq, cmdtmp, entry);
+			free(cmdtmp->name);
+			free(cmdtmp->path);
+			free(cmdtmp);
 		}
 	}
+	TAILQ_INSERT_TAIL(&c->cmdq, cmd, entry);
+}
+
+void
+conf_wm_add(struct conf *c, const char *name, const char *path)
+{
+	struct cmd_ctx	*wm, *wmtmp = NULL, *wmnxt;
+
+	wm = xmalloc(sizeof(*wm));
+	wm->name = xstrdup(name);
+	wm->path = xstrdup(path);
+
+	TAILQ_FOREACH_SAFE(wmtmp, &c->cmdq, entry, wmnxt) {
+		if (strcmp(wmtmp->name, name) == 0) {
+			TAILQ_REMOVE(&c->wmq, wmtmp, entry);
+			free(wmtmp->name);
+			free(wmtmp->path);
+			free(wmtmp);
+		}
+	}
+	TAILQ_INSERT_TAIL(&c->wmq, wm, entry);
 }
 
 void
@@ -425,16 +462,13 @@ void
 conf_client(struct client_ctx *cc)
 {
 	struct winname	*wn;
-	int		 ignore = 0;
 
 	TAILQ_FOREACH(wn, &Conf.ignoreq, entry) {
 		if (strncasecmp(wn->name, cc->name, strlen(wn->name)) == 0) {
-			ignore = 1;
+			cc->flags |= CLIENT_IGNORE;
 			break;
 		}
 	}
-	cc->bwidth = (ignore) ? 0 : Conf.bwidth;
-	cc->flags |= (ignore) ? CLIENT_IGNORE : 0;
 }
 
 void
@@ -442,8 +476,6 @@ conf_screen(struct screen_ctx *sc)
 {
 	unsigned int	 i;
 	XftColor	 xc;
-	Colormap	 colormap = DefaultColormap(X_Dpy, sc->which);
-	Visual		*visual = DefaultVisual(X_Dpy, sc->which);
 
 	sc->gap = Conf.gap;
 	sc->snapdist = Conf.snapdist;
@@ -460,36 +492,35 @@ conf_screen(struct screen_ctx *sc)
 			xu_xorcolor(sc->xftcolor[CWM_COLOR_MENU_BG],
 			    sc->xftcolor[CWM_COLOR_MENU_FG], &xc);
 			xu_xorcolor(sc->xftcolor[CWM_COLOR_MENU_FONT], xc, &xc);
-			if (!XftColorAllocValue(X_Dpy, visual, colormap,
+			if (!XftColorAllocValue(X_Dpy, sc->visual, sc->colormap,
 			    &xc.color, &sc->xftcolor[CWM_COLOR_MENU_FONT_SEL]))
 				warnx("XftColorAllocValue: %s", Conf.color[i]);
 			break;
 		}
-		if (XftColorAllocName(X_Dpy, visual, colormap,
-		    Conf.color[i], &xc)) {
-			sc->xftcolor[i] = xc;
-			XftColorFree(X_Dpy, visual, colormap, &xc);
-		} else {
+		if (!XftColorAllocName(X_Dpy, sc->visual, sc->colormap,
+		    Conf.color[i], &sc->xftcolor[i])) {
 			warnx("XftColorAllocName: %s", Conf.color[i]);
-			XftColorAllocName(X_Dpy, visual, colormap,
+			XftColorAllocName(X_Dpy, sc->visual, sc->colormap,
 			    color_binds[i], &sc->xftcolor[i]);
 		}
 	}
 
-	sc->menu.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);
-
-	sc->menu.xftdraw = XftDrawCreate(X_Dpy, sc->menu.win, visual, colormap);
-	if (sc->menu.xftdraw == NULL)
-		errx(1, "%s: XftDrawCreate", __func__);
-
 	conf_grab_kbd(sc->rootwin);
 }
 
+void
+conf_group(struct screen_ctx *sc)
+{
+	unsigned int	 i;
+
+	for (i = 0; i < nitems(group_binds); i++) {
+		group_init(sc, group_binds[i].num, group_binds[i].name);
+		Conf.ngroups++;
+	}
+}
+
 static const char *
-conf_bind_getmask(const char *name, unsigned int *mask)
+conf_bind_mask(const char *name, unsigned int *mask)
 {
 	char		*dash;
 	const char	*ch;
@@ -497,13 +528,13 @@ conf_bind_getmask(const char *name, unsigned int *mask)
 
 	*mask = 0;
 	if ((dash = strchr(name, '-')) == NULL)
-		return(name);
+		return name;
 	for (i = 0; i < nitems(bind_mods); i++) {
 		if ((ch = strchr(name, bind_mods[i].ch)) != NULL && ch < dash)
 			*mask |= bind_mods[i].mask;
 	}
 	/* Skip past modifiers. */
-	return(dash + 1);
+	return (dash + 1);
 }
 
 int
@@ -516,20 +547,20 @@ conf_bind_key(struct conf *c, const char *bind, const char *cmd)
 
 	if ((strcmp(bind, "all") == 0) && (cmd == NULL)) {
 		conf_unbind_key(c, NULL);
-		return(1);
+		return 1;
 	}
 	kb = xmalloc(sizeof(*kb));
-	key = conf_bind_getmask(bind, &kb->modmask);
+	key = conf_bind_mask(bind, &kb->modmask);
 	kb->press.keysym = XStringToKeysym(key);
 	if (kb->press.keysym == NoSymbol) {
 		warnx("unknown symbol: %s", key);
 		free(kb);
-		return(0);
+		return 0;
 	}
 	conf_unbind_key(c, kb);
 	if (cmd == NULL) {
 		free(kb);
-		return(1);
+		return 1;
 	}
 	cargs = xcalloc(1, sizeof(*cargs));
 	for (i = 0; i < nitems(name_to_func); i++) {
@@ -547,7 +578,7 @@ conf_bind_key(struct conf *c, const char *bind, const char *cmd)
 out:
 	kb->cargs = cargs;
 	TAILQ_INSERT_TAIL(&c->keybindq, kb, entry);
-	return(1);
+	return 1;
 }
 
 static void
@@ -577,20 +608,20 @@ conf_bind_mouse(struct conf *c, const char *bind, const char *cmd)
 
 	if ((strcmp(bind, "all") == 0) && (cmd == NULL)) {
 		conf_unbind_mouse(c, NULL);
-		return(1);
+		return 1;
 	}
 	mb = xmalloc(sizeof(*mb));
-	button = conf_bind_getmask(bind, &mb->modmask);
+	button = conf_bind_mask(bind, &mb->modmask);
 	mb->press.button = strtonum(button, Button1, Button5, &errstr);
 	if (errstr) {
 		warnx("button number is %s: %s", errstr, button);
 		free(mb);
-		return(0);
+		return 0;
 	}
 	conf_unbind_mouse(c, mb);
 	if (cmd == NULL) {
 		free(mb);
-		return(1);
+		return 1;
 	}
 	cargs = xcalloc(1, sizeof(*cargs));
 	for (i = 0; i < nitems(name_to_func); i++) {
@@ -608,7 +639,7 @@ conf_bind_mouse(struct conf *c, const char *bind, const char *cmd)
 out:
 	mb->cargs = cargs;
 	TAILQ_INSERT_TAIL(&c->mousebindq, mb, entry);
-	return(1);
+	return 1;
 }
 
 static void
@@ -617,7 +648,7 @@ conf_unbind_mouse(struct conf *c, struct bind_ctx *unbind)
 	struct bind_ctx		*mb = NULL, *mbnxt;
 
 	TAILQ_FOREACH_SAFE(mb, &c->mousebindq, entry, mbnxt) {
-		if ((unbind == NULL) || 
+		if ((unbind == NULL) ||
 		    ((mb->modmask == unbind->modmask) &&
 		     (mb->press.button == unbind->press.button))) {
 			TAILQ_REMOVE(&c->mousebindq, mb, entry);
@@ -639,6 +670,8 @@ conf_grab_kbd(Window win)
 
 	TAILQ_FOREACH(kb, &Conf.keybindq, entry) {
 		kc = XKeysymToKeycode(X_Dpy, kb->press.keysym);
+		if (kc == 0)
+			continue;
 		if ((XkbKeycodeToKeysym(X_Dpy, kc, 0, 0) != kb->press.keysym) &&
 		    (XkbKeycodeToKeysym(X_Dpy, kc, 0, 1) == kb->press.keysym))
 			kb->modmask |= ShiftMask;
@@ -668,46 +701,3 @@ conf_grab_mouse(Window win)
 		}
 	}
 }
-
-static char *cwmhints[] = {
-	"WM_STATE",
-	"WM_DELETE_WINDOW",
-	"WM_TAKE_FOCUS",
-	"WM_PROTOCOLS",
-	"_MOTIF_WM_HINTS",
-	"UTF8_STRING",
-	"WM_CHANGE_STATE",
-};
-static 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",
-	"_CWM_WM_STATE_FREEZE",
-};
-
-void
-conf_atoms(void)
-{
-	XInternAtoms(X_Dpy, cwmhints, nitems(cwmhints), False, cwmh);
-	XInternAtoms(X_Dpy, ewmhints, nitems(ewmhints), False, ewmh);
-}

cwm.1

@@ -23,6 +23,7 @@
 .Sh SYNOPSIS
 .\" For a program:  program [-abc] file ...
 .Nm cwm
+.Op Fl nv
 .Op Fl c Ar file
 .Op Fl d Ar display
 .Sh DESCRIPTION
@@ -47,6 +48,14 @@ however,
 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
@@ -94,7 +103,7 @@ Cycle through currently visible windows.
 .It Ic MS-Tab
 Reverse cycle through currently visible windows.
 .It Ic CM-x
-Delete current window.
+Close current window.
 .It Ic CM-[n]
 Toggle visibility of group n, where n is 1-9.
 .It Ic CM-a
@@ -143,7 +152,7 @@ will be executed via the configured terminal emulator.
 .It Ic CM-w
 Spawn
 .Dq exec WindowManager
-dialog, allowing a switch to another window manager.
+menu, allowing a switch to another window manager.
 .It Ic CMS-r
 Restart.
 .It Ic CMS-q
@@ -184,6 +193,14 @@ List all available items.
 .It Ic [Esc]
 Cancel.
 .El
+.Pp
+.Nm
+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,
@@ -202,6 +219,11 @@ Window is currently focused.
 .It &
 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
@@ -225,8 +247,7 @@ Selecting an item will warp to that window, unhiding it if necessary.
 Show list of currently defined groups.
 Selecting an item will hide/unhide that group.
 .It Ic M3
-Show list of applications as defined in
-.Pa ~/.cwmrc .
+Show list of applications as defined in the configuration file.
 Selecting an item will spawn that application.
 .El
 .Sh ENVIRONMENT

cwmrc.5

@@ -37,10 +37,8 @@ Arguments containing whitespace should be surrounded by double quotes
 .Pq \&" .
 .Pp
 The following options are accepted:
-.Pp
-.Bl -tag -width Ds -compact
-.It Ic autogroup Ar group windowclass
-.It Ic autogroup Ar group windowname,windowclass
+.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
@@ -62,7 +60,6 @@ used to override
 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 .
-.Pp
 .It Ic bind-key Ar key function
 Bind or rebind key
 .Ar key
@@ -84,6 +81,8 @@ Meta key.
 Shift key.
 .It Ic 4
 Mod4 (windows) key.
+.It Ic 5
+Mod5 (AltGr) key.
 .El
 .Pp
 The
@@ -91,7 +90,6 @@ The
 may either be one from the
 .Sx BIND FUNCTION LIST
 (see below) or the command line that is to be executed.
-.Pp
 .It Ic bind-mouse Ar button function
 Bind or rebind button
 .Ar button
@@ -101,18 +99,10 @@ The modifier keys come first, followed by a
 .Sq - ,
 then the button number.
 .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.
-.El
+The same modifiers are recognised as for
+.Ar key
+in
+.Nm bind-key .
 .Pp
 The following buttons are recognised:
 .Pp
@@ -134,38 +124,27 @@ The
 may be taken from the
 .Sx BIND FUNCTION LIST
 (see below) or the command line that is to be executed.
-.Pp
 .It Ic borderwidth Ar pixels
 Set the window border width to
 .Ar pixels .
-.Pp
 .It Ic color activeborder Ar color
 Set the color of the active border.
-.Pp
 .It Ic color font Ar color
 Set menu font color.
-.Pp
 .It Ic color selfont Ar color
 Set font color for selected menu item.
-.Pp
 .It Ic color groupborder Ar color
 Set the color of the border while grouping a window.
-.Pp
 .It Ic color inactiveborder Ar color
 Set the color of the inactive border.
-.Pp
 .It Ic color menubg Ar color
 Set menu background color.
-.Pp
 .It Ic color menufg Ar color
 Set menu foreground color.
-.Pp
 .It Ic color urgencyborder Ar color
 Set the color of the border of a window indicating urgency.
-.Pp
 .It Ic color ungroupborder Ar color
 Set the color of the border while ungrouping a window.
-.Pp
 .It Ic command Ar name path
 Every
 .Ar name
@@ -173,7 +152,7 @@ entry is shown in the application menu.
 When selected, the defined
 .Ar path
 is executed with
-.Xr execve 2 .
+.Xr execvp 3 .
 .Pp
 The
 .Ar name
@@ -189,13 +168,11 @@ The defaults are
 and
 .Xr xlock 1 ,
 respectively.
-.Pp
 .It Ic fontname Ar font
 Change the default
 .Ar font
 for
 .Xr Xft 3 .
-.Pp
 .It Ic gap Ar top bottom left right
 Define a
 .Dq gap
@@ -206,28 +183,30 @@ This
 can be used for applications such as
 .Xr xclock 1 ,
 where the user may wish to remain visible.
-.Pp
+.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.
-.Pp
 .It Ic moveamount Ar pixels
 Set a default size for the keyboard movement bindings,
 in pixels.
 The default is 1.
-.Pp
 .It Ic snapdist Ar pixels
 Minimum distance to snap-to adjacent edge, in pixels.
 The default is 0.
-.Pp
 .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.
-.Pp
 .It Ic unbind-key Ar key
 Unbind function bound to
 .Ar key .
@@ -236,7 +215,6 @@ A special
 keyword
 .Dq all
 can be used to unbind all keys.
-.Pp
 .It Ic unbind-mouse Ar button
 Unbind function bound to
 .Ar button .
@@ -245,6 +223,19 @@ A special
 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
@@ -282,6 +273,10 @@ menu.
 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
@@ -300,8 +295,8 @@ Reverse cycle through windows.
 Forward cycle through windows in current group.
 .It window-rcycle-ingroup
 Reverse cycle through windows in current group.
-.It window-delete
-Delete current window.
+.It window-close
+Close current window.
 .It window-hide
 Hide current window.
 .It window-lower
@@ -324,11 +319,15 @@ Vertically maximize current window (gap + border honored).
 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 half of the vertical screen space.
+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 half of the horizontal screen space.
+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.
@@ -398,6 +397,22 @@ pixels right.
 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

group.c

@@ -35,39 +35,32 @@
 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_setactive(struct group_ctx *);
-
-const char *num_to_name[] = {
-	"nogroup", "one", "two", "three", "four", "five", "six",
-	"seven", "eight", "nine"
-};
+static void		 group_set_active(struct group_ctx *);
 
 void
 group_assign(struct group_ctx *gc, struct client_ctx *cc)
 {
-	if (cc->gc != NULL)
-		TAILQ_REMOVE(&cc->gc->clientq, cc, group_entry);
-
 	if ((gc != NULL) && (gc->num == 0))
 		gc = NULL;
 
 	cc->gc = gc;
 
-	if (cc->gc != NULL)
-		TAILQ_INSERT_TAIL(&gc->clientq, cc, group_entry);
-
-	xu_ewmh_net_wm_desktop(cc);
+	xu_ewmh_set_net_wm_desktop(cc);
 }
 
 void
 group_hide(struct group_ctx *gc)
 {
+	struct screen_ctx	*sc = gc->sc;
 	struct client_ctx	*cc;
 
 	screen_updatestackingorder(gc->sc);
 
-	TAILQ_FOREACH(cc, &gc->clientq, group_entry) {
-		if (!(cc->flags & CLIENT_STICKY))
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
+		if (!(cc->flags & CLIENT_STICKY) &&
+		    !(cc->flags & CLIENT_HIDDEN))
 			client_hide(cc);
 	}
 }
@@ -75,33 +68,41 @@ group_hide(struct group_ctx *gc)
 void
 group_show(struct group_ctx *gc)
 {
+	struct screen_ctx	*sc = gc->sc;
 	struct client_ctx	*cc;
 
-	TAILQ_FOREACH(cc, &gc->clientq, group_entry) {
-		if (!(cc->flags & CLIENT_STICKY))
-			client_unhide(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_setactive(gc);
+	group_set_active(gc);
 }
 
 static void
 group_restack(struct group_ctx *gc)
 {
+	struct screen_ctx	*sc = gc->sc;
 	struct client_ctx	*cc;
 	Window			*winlist;
 	int			 i, lastempty = -1;
 	int			 nwins = 0, highstack = 0;
 
-	TAILQ_FOREACH(cc, &gc->clientq, group_entry) {
+	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 for XRestackWindows(). */
-	TAILQ_FOREACH(cc, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
 		winlist[highstack - cc->stackingorder] = cc->win;
 		nwins++;
 	}
@@ -122,24 +123,22 @@ group_restack(struct group_ctx *gc)
 }
 
 void
-group_init(struct screen_ctx *sc, int num)
+group_init(struct screen_ctx *sc, int num, const char *name)
 {
 	struct group_ctx	*gc;
 
 	gc = xmalloc(sizeof(*gc));
 	gc->sc = sc;
-	gc->name = xstrdup(num_to_name[num]);
+	gc->name = xstrdup(name);
 	gc->num = num;
-	TAILQ_INIT(&gc->clientq);
-
 	TAILQ_INSERT_TAIL(&sc->groupq, gc, entry);
 
 	if (num == 1)
-		group_setactive(gc);
+		group_set_active(gc);
 }
 
 void
-group_setactive(struct group_ctx *gc)
+group_set_active(struct group_ctx *gc)
 {
 	struct screen_ctx	*sc = gc->sc;
 
@@ -154,90 +153,61 @@ group_movetogroup(struct client_ctx *cc, int idx)
 	struct screen_ctx	*sc = cc->sc;
 	struct group_ctx	*gc;
 
-	if (idx < 0 || idx >= Conf.ngroups)
-		errx(1, "%s: index out of range (%d)", __func__, idx);
-
 	TAILQ_FOREACH(gc, &sc->groupq, entry) {
-		if (gc->num == idx)
-			break;
+		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);
+		}
 	}
-
-	if (cc->gc == gc)
-		return;
-	if (gc->num != 0 && group_holds_only_hidden(gc))
-		client_hide(cc);
-	group_assign(gc, cc);
 }
 
 void
-group_toggle_membership_enter(struct client_ctx *cc)
+group_toggle_membership(struct client_ctx *cc)
 {
 	struct screen_ctx	*sc = cc->sc;
 	struct group_ctx	*gc = sc->group_active;
 
-	if (gc == cc->gc) {
+	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);
-}
-
-void
-group_toggle_membership_leave(struct client_ctx *cc)
-{
-	cc->flags &= ~CLIENT_HIGHLIGHT;
 	client_draw_border(cc);
 }
 
 int
 group_holds_only_sticky(struct group_ctx *gc)
 {
+	struct screen_ctx	*sc = gc->sc;
 	struct client_ctx	*cc;
 
-	TAILQ_FOREACH(cc, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
 		if (!(cc->flags & CLIENT_STICKY))
-			return(0);
+			return 0;
 	}
-	return(1);
+	return 1;
 }
 
 int
 group_holds_only_hidden(struct group_ctx *gc)
 {
+	struct screen_ctx	*sc = gc->sc;
 	struct client_ctx	*cc;
 
-	TAILQ_FOREACH(cc, &gc->clientq, group_entry) {
+	TAILQ_FOREACH(cc, &sc->clientq, entry) {
+		if (cc->gc != gc)
+			continue;
 		if (!(cc->flags & (CLIENT_HIDDEN | CLIENT_STICKY)))
-			return(0);
-	}
-	return(1);
-}
-
-void
-group_hidetoggle(struct screen_ctx *sc, int idx)
-{
-	struct group_ctx	*gc;
-
-	if (idx < 0 || idx >= Conf.ngroups)
-		errx(1, "%s: index out of range (%d)", __func__, idx);
-
-	TAILQ_FOREACH(gc, &sc->groupq, entry) {
-		if (gc->num == idx)
-			break;
-	}
-
-	if (group_holds_only_hidden(gc))
-		group_show(gc);
-	else {
-		group_hide(gc);
-		/* make clients stick to empty group */
-		if (TAILQ_EMPTY(&gc->clientq))
-			group_setactive(gc);
+			return 0;
 	}
+	return 1;
 }
 
 void
@@ -245,8 +215,8 @@ group_only(struct screen_ctx *sc, int idx)
 {
 	struct group_ctx	*gc;
 
-	if (idx < 0 || idx >= Conf.ngroups)
-		errx(1, "%s: index out of range (%d)", __func__, idx);
+	if (sc->group_last != sc->group_active)
+		sc->group_last = sc->group_active;
 
 	TAILQ_FOREACH(gc, &sc->groupq, entry) {
 		if (gc->num == idx)
@@ -256,6 +226,52 @@ group_only(struct screen_ctx *sc, int idx)
 	}
 }
 
+void
+group_toggle(struct screen_ctx *sc, int idx)
+{
+	struct group_ctx	*gc;
+
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (gc->num == idx) {
+			if (group_holds_only_hidden(gc))
+				group_show(gc);
+			else
+				group_hide(gc);
+		}
+	}
+}
+
+void
+group_toggle_all(struct screen_ctx *sc)
+{
+	struct group_ctx	*gc;
+
+	TAILQ_FOREACH(gc, &sc->groupq, entry) {
+		if (sc->hideall)
+			group_show(gc);
+		else
+			group_hide(gc);
+	}
+	sc->hideall = !sc->hideall;
+}
+
+void
+group_close(struct screen_ctx *sc, int idx)
+{
+	struct group_ctx	*gc;
+	struct client_ctx	*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);
+			}
+		}
+	}
+}
+
 void
 group_cycle(struct screen_ctx *sc, int flags)
 {
@@ -276,7 +292,6 @@ group_cycle(struct screen_ctx *sc, int flags)
 		else if (!group_holds_only_hidden(newgc))
 			group_hide(newgc);
 	}
-
 	if (showgroup == NULL)
 		return;
 
@@ -285,7 +300,7 @@ group_cycle(struct screen_ctx *sc, int flags)
 	if (group_holds_only_hidden(showgroup))
 		group_show(showgroup);
 	else
-		group_setactive(showgroup);
+		group_set_active(showgroup);
 }
 
 static struct group_ctx *
@@ -308,43 +323,27 @@ group_prev(struct group_ctx *gc)
 	    newgc : TAILQ_LAST(&sc->groupq, group_q));
 }
 
-void
-group_alltoggle(struct screen_ctx *sc)
-{
-	struct group_ctx	*gc;
-
-	TAILQ_FOREACH(gc, &sc->groupq, entry) {
-		if (sc->hideall)
-			group_show(gc);
-		else
-			group_hide(gc);
-	}
-	sc->hideall = !sc->hideall;
-}
-
 int
 group_restore(struct client_ctx *cc)
 {
 	struct screen_ctx	*sc = cc->sc;
 	struct group_ctx	*gc;
 	int			 num;
-	long			*grpnum;
+	long			 grpnum;
 
-	if (xu_getprop(cc->win, ewmh[_NET_WM_DESKTOP], XA_CARDINAL, 1L,
-	    (unsigned char **)&grpnum) <= 0)
-		return(0);
+	if (!xu_ewmh_get_net_wm_desktop(cc, &grpnum))
+		return 0;
 
-	num = (*grpnum == -1) ? 0 : *grpnum;
+	num = (grpnum == -1) ? 0 : grpnum;
 	num = MIN(num, (Conf.ngroups - 1));
-	XFree(grpnum);
 
 	TAILQ_FOREACH(gc, &sc->groupq, entry) {
 		if (gc->num == num) {
 			group_assign(gc, cc);
-			return(1);
+			return 1;
 		}
 	}
-	return(0);
+	return 0;
 }
 
 int
@@ -355,13 +354,13 @@ group_autogroup(struct client_ctx *cc)
 	struct group_ctx	*gc;
 	int			 num = -1, both_match = 0;
 
-	if (cc->ch.res_class == NULL || cc->ch.res_name == NULL)
-		return(0);
+	if (cc->res_class == NULL || cc->res_name == NULL)
+		return 0;
 
 	TAILQ_FOREACH(ag, &Conf.autogroupq, entry) {
-		if (strcmp(ag->class, cc->ch.res_class) == 0) {
+		if (strcmp(ag->class, cc->res_class) == 0) {
 			if ((ag->name != NULL) &&
-			    (strcmp(ag->name, cc->ch.res_name) == 0)) {
+			    (strcmp(ag->name, cc->res_name) == 0)) {
 				num = ag->num;
 				both_match = 1;
 			} else if (ag->name == NULL && !both_match)
@@ -372,8 +371,8 @@ group_autogroup(struct client_ctx *cc)
 	TAILQ_FOREACH(gc, &sc->groupq, entry) {
 		if (gc->num == num) {
 			group_assign(gc, cc);
-			return(1);
+			return 1;
 		}
 	}
-	return(0);
+	return 0;
 }

kbfunc.c

@@ -23,6 +23,7 @@
 
 #include <sys/types.h>
 #include "queue.h"
+#include <sys/stat.h>
 
 #include <dirent.h>
 #include <err.h>
@@ -61,7 +62,7 @@ kbfunc_amount(int flags, int amt, int *mx, int *my)
 	if (flags & CWM_BIGAMOUNT)
 		amt *= CWM_FACTOR;
 
-	switch (flags & DIRECTIONMASK) {
+	switch (flags & (CWM_UP | CWM_DOWN | CWM_LEFT | CWM_RIGHT)) {
 	case CWM_UP:
 		*my -= amt;
 		break;
@@ -86,8 +87,8 @@ kbfunc_ptrmove(void *ctx, struct cargs *cargs)
 
 	kbfunc_amount(cargs->flag, Conf.mamount, &mx, &my);
 
-	xu_ptr_getpos(sc->rootwin, &x, &y);
-	xu_ptr_setpos(sc->rootwin, x + mx, y + my);
+	xu_ptr_get(sc->rootwin, &x, &y);
+	xu_ptr_set(sc->rootwin, x + mx, y + my);
 }
 
 void
@@ -134,7 +135,7 @@ kbfunc_client_move_kb(void *ctx, struct cargs *cargs)
 
 	area = screen_area(sc,
 	    cc->geom.x + cc->geom.w / 2,
-	    cc->geom.y + cc->geom.h / 2, CWM_GAP);
+	    cc->geom.y + cc->geom.h / 2, 1);
 	cc->geom.x += client_snapcalc(cc->geom.x,
 	    cc->geom.x + cc->geom.w + (cc->bwidth * 2),
 	    area.x, area.x + area.w, sc->snapdist);
@@ -144,6 +145,7 @@ kbfunc_client_move_kb(void *ctx, struct cargs *cargs)
 
 	client_move(cc);
 	client_ptr_inbound(cc, 1);
+	XSync(X_Dpy, True);
 }
 
 static void
@@ -168,10 +170,10 @@ kbfunc_client_move_mb(void *ctx, struct cargs *cargs)
 	    CurrentTime) != GrabSuccess)
 		return;
 
-	menu_windraw(sc, cc->win, "%4d, %-4d", cc->geom.x, cc->geom.y);
-
+	screen_prop_win_create(sc, cc->win);
+	screen_prop_win_draw(sc, "%+5d%+5d", cc->geom.x, cc->geom.y);
 	while (move) {
-		XWindowEvent(X_Dpy, cc->win, MOUSEMASK, &ev);
+		XMaskEvent(X_Dpy, MOUSEMASK, &ev);
 		switch (ev.type) {
 		case MotionNotify:
 			/* not more than 60 times / second */
@@ -184,7 +186,7 @@ kbfunc_client_move_mb(void *ctx, struct cargs *cargs)
 
 			area = screen_area(sc,
 			    cc->geom.x + cc->geom.w / 2,
-			    cc->geom.y + cc->geom.h / 2, CWM_GAP);
+			    cc->geom.y + cc->geom.h / 2, 1);
 			cc->geom.x += client_snapcalc(cc->geom.x,
 			    cc->geom.x + cc->geom.w + (cc->bwidth * 2),
 			    area.x, area.x + area.w, sc->snapdist);
@@ -192,8 +194,8 @@ kbfunc_client_move_mb(void *ctx, struct cargs *cargs)
 			    cc->geom.y + cc->geom.h + (cc->bwidth * 2),
 			    area.y, area.y + area.h, sc->snapdist);
 			client_move(cc);
-			menu_windraw(sc, cc->win,
-			    "%4d, %-4d", cc->geom.x, cc->geom.y);
+			screen_prop_win_draw(sc,
+			    "%+5d%+5d", cc->geom.x, cc->geom.y);
 			break;
 		case ButtonRelease:
 			move = 0;
@@ -202,8 +204,7 @@ kbfunc_client_move_mb(void *ctx, struct cargs *cargs)
 	}
 	if (ltime)
 		client_move(cc);
-	XUnmapWindow(X_Dpy, sc->menu.win);
-	XReparentWindow(X_Dpy, sc->menu.win, sc->rootwin, 0, 0);
+	screen_prop_win_destroy(sc);
 	XUngrabPointer(X_Dpy, CurrentTime);
 }
 
@@ -233,6 +234,7 @@ kbfunc_client_resize_kb(void *ctx, struct cargs *cargs)
 
 	client_resize(cc, 1);
 	client_ptr_inbound(cc, 1);
+	XSync(X_Dpy, True);
 }
 
 static void
@@ -248,18 +250,19 @@ kbfunc_client_resize_mb(void *ctx, struct cargs *cargs)
 		return;
 
 	client_raise(cc);
-	client_ptrsave(cc);
+	client_ptr_save(cc);
 
-	xu_ptr_setpos(cc->win, cc->geom.w, cc->geom.h);
+	xu_ptr_set(cc->win, cc->geom.w, cc->geom.h);
 
 	if (XGrabPointer(X_Dpy, cc->win, False, MOUSEMASK,
 	    GrabModeAsync, GrabModeAsync, None, Conf.cursor[CF_RESIZE],
 	    CurrentTime) != GrabSuccess)
 		return;
 
-	menu_windraw(sc, cc->win, "%4d x %-4d", cc->dim.w, cc->dim.h);
+	screen_prop_win_create(sc, cc->win);
+	screen_prop_win_draw(sc, "%4d x %-4d", cc->dim.w, cc->dim.h);
 	while (resize) {
-		XWindowEvent(X_Dpy, cc->win, MOUSEMASK, &ev);
+		XMaskEvent(X_Dpy, MOUSEMASK, &ev);
 		switch (ev.type) {
 		case MotionNotify:
 			/* not more than 60 times / second */
@@ -269,9 +272,9 @@ kbfunc_client_resize_mb(void *ctx, struct cargs *cargs)
 
 			cc->geom.w = ev.xmotion.x;
 			cc->geom.h = ev.xmotion.y;
-			client_applysizehints(cc);
+			client_apply_sizehints(cc);
 			client_resize(cc, 1);
-			menu_windraw(sc, cc->win,
+			screen_prop_win_draw(sc,
 			    "%4d x %-4d", cc->dim.w, cc->dim.h);
 			break;
 		case ButtonRelease:
@@ -281,8 +284,7 @@ kbfunc_client_resize_mb(void *ctx, struct cargs *cargs)
 	}
 	if (ltime)
 		client_resize(cc, 1);
-	XUnmapWindow(X_Dpy, sc->menu.win);
-	XReparentWindow(X_Dpy, sc->menu.win, sc->rootwin, 0, 0);
+	screen_prop_win_destroy(sc);
 	XUngrabPointer(X_Dpy, CurrentTime);
 
 	/* Make sure the pointer stays within the window. */
@@ -290,15 +292,52 @@ kbfunc_client_resize_mb(void *ctx, struct cargs *cargs)
 }
 
 void
-kbfunc_client_delete(void *ctx, struct cargs *cargs)
+kbfunc_client_snap(void *ctx, struct cargs *cargs)
 {
-	client_send_delete(ctx);
+	struct client_ctx	*cc = ctx;
+	struct screen_ctx	*sc = cc->sc;
+	struct geom		 area;
+	int			 flags;
+
+	area = screen_area(sc,
+	    cc->geom.x + cc->geom.w / 2,
+	    cc->geom.y + cc->geom.h / 2, 1);
+
+	flags = cargs->flag;
+	while (flags) {
+		if (flags & CWM_UP) {
+			cc->geom.y = area.y;
+			flags &= ~CWM_UP;
+		}
+		if (flags & CWM_LEFT) {
+			cc->geom.x = area.x;
+			flags &= ~CWM_LEFT;
+		}
+		if (flags & CWM_RIGHT) {
+			cc->geom.x = area.x + area.w - cc->geom.w -
+			    (cc->bwidth * 2);
+			flags &= ~CWM_RIGHT;
+		}
+		if (flags & CWM_DOWN) {
+			cc->geom.y = area.y + area.h - cc->geom.h -
+			    (cc->bwidth * 2);
+			flags &= ~CWM_DOWN;
+		}
+	}
+	client_move(cc);
+	client_ptr_inbound(cc, 1);
+}
+
+void
+kbfunc_client_close(void *ctx, struct cargs *cargs)
+{
+	client_close(ctx);
 }
 
 void
 kbfunc_client_lower(void *ctx, struct cargs *cargs)
 {
-	client_ptrsave(ctx);
+	client_ptr_save(ctx);
 	client_lower(ctx);
 }
 
@@ -365,7 +404,65 @@ kbfunc_client_vtile(void *ctx, struct cargs *cargs)
 void
 kbfunc_client_cycle(void *ctx, struct cargs *cargs)
 {
-	client_cycle(ctx, cargs->flag);
+	struct screen_ctx	*sc = ctx;
+	struct client_ctx	*newcc, *oldcc, *prevcc;
+	int			 again = 1, flags = cargs->flag;
+
+	/* For X apps that ignore/steal events. */
+	if (cargs->xev == CWM_XEV_KEY)
+		XGrabKeyboard(X_Dpy, sc->rootwin, True,
+		    GrabModeAsync, GrabModeAsync, CurrentTime);
+
+	if (TAILQ_EMPTY(&sc->clientq))
+		return;
+
+	prevcc = TAILQ_FIRST(&sc->clientq);
+	oldcc = client_current(sc);
+	if (oldcc == NULL)
+		oldcc = (flags & CWM_CYCLE_REVERSE) ?
+		    TAILQ_LAST(&sc->clientq, client_q) :
+		    TAILQ_FIRST(&sc->clientq);
+
+	newcc = oldcc;
+	while (again) {
+		again = 0;
+
+		newcc = (flags & CWM_CYCLE_REVERSE) ? client_prev(newcc) :
+		    client_next(newcc);
+
+		/* Only cycle visible and non-ignored windows. */
+		if ((newcc->flags & (CLIENT_SKIP_CYCLE)) ||
+		    ((flags & CWM_CYCLE_INGROUP) &&
+		    (newcc->gc != oldcc->gc)))
+			again = 1;
+
+		/* Is oldcc the only non-hidden window? */
+		if (newcc == oldcc) {
+			if (again)
+				return;	/* No windows visible. */
+			break;
+		}
+	}
+
+	/* Reset when cycling mod is released. XXX I hate this hack */
+	sc->cycling = 1;
+	client_ptr_save(oldcc);
+	client_raise(prevcc);
+	client_raise(newcc);
+	if (!client_inbound(newcc, newcc->ptr.x, newcc->ptr.y)) {
+		newcc->ptr.x = newcc->geom.w / 2;
+		newcc->ptr.y = newcc->geom.h / 2;
+	}
+
+	/* When no client is active, warp pointer to last active. */
+	if (oldcc->flags & (CLIENT_ACTIVE))
+		client_ptr_warp(newcc);
+	else if (oldcc->flags & (CLIENT_SKIP_CYCLE))
+		client_ptr_warp(newcc);
+	else {
+		client_raise(oldcc);
+		client_ptr_warp(oldcc);
+	}
 }
 
 void
@@ -373,12 +470,12 @@ kbfunc_client_toggle_group(void *ctx, struct cargs *cargs)
 {
 	struct client_ctx	*cc = ctx;
 
-	/* For X apps that steal events. */
+	/* For X apps that ignore/steal events. */
 	if (cargs->xev == CWM_XEV_KEY)
 		XGrabKeyboard(X_Dpy, cc->win, True,
 		    GrabModeAsync, GrabModeAsync, CurrentTime);
 
-	group_toggle_membership_enter(cc);
+	group_toggle_membership(cc);
 }
 
 void
@@ -387,30 +484,44 @@ kbfunc_client_movetogroup(void *ctx, struct cargs *cargs)
 	group_movetogroup(ctx, cargs->flag);
 }
 
-void
-kbfunc_group_toggle(void *ctx, struct cargs *cargs)
-{
-	group_hidetoggle(ctx, cargs->flag);
-}
-
 void
 kbfunc_group_only(void *ctx, struct cargs *cargs)
 {
 	group_only(ctx, cargs->flag);
 }
 
+void
+kbfunc_group_last(void *ctx, struct cargs *cargs)
+{
+	struct screen_ctx	*sc = ctx;
+
+	group_only(ctx, sc->group_last->num);
+}
+
+void
+kbfunc_group_toggle(void *ctx, struct cargs *cargs)
+{
+	group_toggle(ctx, cargs->flag);
+}
+
+void
+kbfunc_group_toggle_all(void *ctx, struct cargs *cargs)
+{
+	group_toggle_all(ctx);
+}
+
+void
+kbfunc_group_close(void *ctx, struct cargs *cargs)
+{
+	group_close(ctx, cargs->flag);
+}
+
 void
 kbfunc_group_cycle(void *ctx, struct cargs *cargs)
 {
 	group_cycle(ctx, cargs->flag);
 }
 
-void
-kbfunc_group_alltoggle(void *ctx, struct cargs *cargs)
-{
-	group_alltoggle(ctx);
-}
-
 void
 kbfunc_menu_client(void *ctx, struct cargs *cargs)
 {
@@ -418,32 +529,25 @@ kbfunc_menu_client(void *ctx, struct cargs *cargs)
 	struct client_ctx	*cc, *old_cc;
 	struct menu		*mi;
 	struct menu_q		 menuq;
-	int			 m = (cargs->xev == CWM_XEV_BTN);
-	int			 all = (cargs->flag & CWM_MENU_WINDOW_ALL);
+	int			 mflags = 0;
 
-	old_cc = client_current();
+	if (cargs->xev == CWM_XEV_BTN)
+		mflags |= CWM_MENU_LIST;
 
 	TAILQ_INIT(&menuq);
 	TAILQ_FOREACH(cc, &sc->clientq, entry) {
-		if (!all) {
-			if (cc->flags & CLIENT_HIDDEN)
-				menuq_add(&menuq, cc, NULL);
-		} else
+		if ((cargs->flag & CWM_MENU_WINDOW_ALL) ||
+		    (cc->flags & CLIENT_HIDDEN))
 			menuq_add(&menuq, cc, NULL);
 	}
 
-	if ((mi = menu_filter(sc, &menuq,
-	    (m) ? NULL : "window", NULL,
-	    ((m) ? CWM_MENU_LIST : 0),
+	if ((mi = menu_filter(sc, &menuq, "window", NULL, mflags,
 	    search_match_client, search_print_client)) != NULL) {
 		cc = (struct client_ctx *)mi->ctx;
-		if (cc->flags & CLIENT_HIDDEN)
-			client_unhide(cc);
-		else
-			client_raise(cc);
-		if (old_cc)
-			client_ptrsave(old_cc);
-		client_ptrwarp(cc);
+		client_show(cc);
+		if ((old_cc = client_current(sc)) != NULL)
+			client_ptr_save(old_cc);
+		client_ptr_warp(cc);
 	}
 
 	menuq_clear(&menuq);
@@ -456,21 +560,21 @@ kbfunc_menu_cmd(void *ctx, struct cargs *cargs)
 	struct cmd_ctx		*cmd;
 	struct menu		*mi;
 	struct menu_q		 menuq;
-	int			 m = (cargs->xev == CWM_XEV_BTN);
+	int			 mflags = 0;
+
+	if (cargs->xev == CWM_XEV_BTN)
+		mflags |= CWM_MENU_LIST;
 
 	TAILQ_INIT(&menuq);
 	TAILQ_FOREACH(cmd, &Conf.cmdq, entry) {
 		if ((strcmp(cmd->name, "lock") == 0) ||
 		    (strcmp(cmd->name, "term") == 0))
 			continue;
-		/* search_match_text() needs mi->text */
-		menuq_add(&menuq, cmd, "%s", cmd->name);
+		menuq_add(&menuq, cmd, NULL);
 	}
 
-	if ((mi = menu_filter(sc, &menuq,
-	    (m) ? NULL : "application", NULL,
-	    ((m) ? CWM_MENU_LIST : 0),
-	    search_match_text, search_print_cmd)) != NULL) {
+	if ((mi = menu_filter(sc, &menuq, "application", NULL, mflags,
+	    search_match_cmd, search_print_cmd)) != NULL) {
 		cmd = (struct cmd_ctx *)mi->ctx;
 		u_spawn(cmd->path);
 	}
@@ -485,18 +589,20 @@ kbfunc_menu_group(void *ctx, struct cargs *cargs)
 	struct group_ctx	*gc;
 	struct menu		*mi;
 	struct menu_q		 menuq;
-	int			 m = (cargs->xev == CWM_XEV_BTN);
+	int			 mflags = 0;
+
+	if (cargs->xev == CWM_XEV_BTN)
+		mflags |= CWM_MENU_LIST;
 
 	TAILQ_INIT(&menuq);
 	TAILQ_FOREACH(gc, &sc->groupq, entry) {
 		if (group_holds_only_sticky(gc))
 			continue;
-		menuq_add(&menuq, gc, "%d %s", gc->num, gc->name);
+		menuq_add(&menuq, gc, NULL);
 	}
 
-	if ((mi = menu_filter(sc, &menuq,
-	    (m) ? NULL : "group", NULL, (CWM_MENU_LIST),
-	    search_match_text, search_print_group)) != NULL) {
+	if ((mi = menu_filter(sc, &menuq, "group", NULL, mflags,
+	    search_match_group, search_print_group)) != NULL) {
 		gc = (struct group_ctx *)mi->ctx;
 		(group_holds_only_hidden(gc)) ?
 		    group_show(gc) : group_hide(gc);
@@ -505,6 +611,33 @@ kbfunc_menu_group(void *ctx, struct cargs *cargs)
 	menuq_clear(&menuq);
 }
 
+void
+kbfunc_menu_wm(void *ctx, struct cargs *cargs)
+{
+	struct screen_ctx	*sc = ctx;
+	struct cmd_ctx		*wm;
+	struct menu		*mi;
+	struct menu_q		 menuq;
+	int			 mflags = 0;
+
+	if (cargs->xev == CWM_XEV_BTN)
+		mflags |= CWM_MENU_LIST;
+
+	TAILQ_INIT(&menuq);
+	TAILQ_FOREACH(wm, &Conf.wmq, entry)
+		menuq_add(&menuq, wm, NULL);
+
+	if ((mi = menu_filter(sc, &menuq, "wm", NULL, mflags,
+	    search_match_wm, search_print_wm)) != NULL) {
+		wm = (struct cmd_ctx *)mi->ctx;
+		free(Conf.wm_argv);
+		Conf.wm_argv = xstrdup(wm->path);
+		cwm_status = CWM_EXEC_WM;
+	}
+
+	menuq_clear(&menuq);
+}
+
 void
 kbfunc_menu_exec(void *ctx, struct cargs *cargs)
 {
@@ -513,24 +646,12 @@ kbfunc_menu_exec(void *ctx, struct cargs *cargs)
 	char			**ap, *paths[NPATHS], *path, *pathcpy;
 	char			 tpath[PATH_MAX];
 	struct stat		 sb;
-	const char		*label;
 	DIR			*dirp;
 	struct dirent		*dp;
 	struct menu		*mi;
 	struct menu_q		 menuq;
-	int			 l, i, cmd = cargs->flag;
-
-	switch (cmd) {
-	case CWM_MENU_EXEC_EXEC:
-		label = "exec";
-		break;
-	case CWM_MENU_EXEC_WM:
-		label = "wm";
-		break;
-	default:
-		errx(1, "%s: invalid cmd %d", __func__, cmd);
-		/* NOTREACHED */
-	}
+	int			 l, i;
+	int			 mflags = (CWM_MENU_DUMMY | CWM_MENU_FILE);
 
 	TAILQ_INIT(&menuq);
 
@@ -559,7 +680,7 @@ kbfunc_menu_exec(void *ctx, struct cargs *cargs)
 				/* lstat(2) in case d_type isn't supported. */
 				if (lstat(tpath, &sb) == -1)
 					continue;
-				if (!S_ISREG(sb.st_mode) && 
+				if (!S_ISREG(sb.st_mode) &&
 				    !S_ISLNK(sb.st_mode))
 					continue;
 			}
@@ -570,24 +691,11 @@ kbfunc_menu_exec(void *ctx, struct cargs *cargs)
 	}
 	free(path);
 
-	if ((mi = menu_filter(sc, &menuq, label, NULL,
-	    (CWM_MENU_DUMMY | CWM_MENU_FILE),
+	if ((mi = menu_filter(sc, &menuq, "exec", NULL, mflags,
 	    search_match_exec, search_print_text)) != NULL) {
 		if (mi->text[0] == '\0')
 			goto out;
-		switch (cmd) {
-		case CWM_MENU_EXEC_EXEC:
-			u_spawn(mi->text);
-			break;
-		case CWM_MENU_EXEC_WM:
-			cwm_status = CWM_EXEC_WM;
-			free(Conf.wm_argv);
-			Conf.wm_argv = xstrdup(mi->text);
-			break;
-		default:
-			errx(1, "%s: egad, cmd changed value!", __func__);
-			/* NOTREACHED */
-		}
+		u_spawn(mi->text);
 	}
 out:
 	if (mi != NULL && mi->dummy)
@@ -609,6 +717,7 @@ kbfunc_menu_ssh(void *ctx, struct cargs *cargs)
 	int			 l;
 	size_t			 len;
 	ssize_t			 slen;
+	int			 mflags = (CWM_MENU_DUMMY);
 
 	TAILQ_FOREACH(cmd, &Conf.cmdq, entry) {
 		if (strcmp(cmd->name, "term") == 0)
@@ -631,9 +740,8 @@ kbfunc_menu_ssh(void *ctx, struct cargs *cargs)
 		/* skip hashed hosts */
 		if (strncmp(buf, HASH_MARKER, strlen(HASH_MARKER)) == 0)
 			continue;
-		for (p = buf; *p != ',' && *p != ' ' && p != buf + slen; p++) {
-			/* do nothing */
-		}
+		for (p = buf; *p != ',' && *p != ' ' && p != buf + slen; p++)
+			;
 		/* ignore badness */
 		if (p - buf + 1 > sizeof(hostbuf))
 			continue;
@@ -645,7 +753,7 @@ kbfunc_menu_ssh(void *ctx, struct cargs *cargs)
 		err(1, "%s", path);
 	(void)fclose(fp);
 menu:
-	if ((mi = menu_filter(sc, &menuq, "ssh", NULL, (CWM_MENU_DUMMY),
+	if ((mi = menu_filter(sc, &menuq, "ssh", NULL, mflags,
 	    search_match_text, search_print_text)) != NULL) {
 		if (mi->text[0] == '\0')
 			goto out;
@@ -667,11 +775,12 @@ kbfunc_client_menu_label(void *ctx, struct cargs *cargs)
 	struct client_ctx	*cc = ctx;
 	struct menu		*mi;
 	struct menu_q		 menuq;
+	int			 mflags = (CWM_MENU_DUMMY);
 
 	TAILQ_INIT(&menuq);
 
 	/* dummy is set, so this will always return */
-	mi = menu_filter(cc->sc, &menuq, "label", cc->label, (CWM_MENU_DUMMY),
+	mi = menu_filter(cc->sc, &menuq, "label", cc->label, mflags,
 	    search_match_text, search_print_text);
 
 	if (!mi->abort) {

menu.c

@@ -37,6 +37,10 @@
 #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,
@@ -45,10 +49,12 @@ enum ctltype {
 
 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			 hasprompt;
 	int			 list;
 	int			 listing;
 	int			 changed;
@@ -56,7 +62,6 @@ struct menu_ctx {
 	int			 entry;
 	int			 num;
 	int 			 flags;
-	struct geom		 geom;
 	void (*match)(struct menu_q *, struct menu_q *, char *);
 	void (*print)(struct menu *, int);
 };
@@ -85,15 +90,13 @@ menu_filter(struct screen_ctx *sc, struct menu_q *menuq, const char *prompt,
 	struct menu		*mi = NULL;
 	XEvent			 e;
 	Window			 focuswin;
-	int			 evmask, focusrevert;
-	int			 xsave, ysave, xcur, ycur;
+	int			 focusrevert, xsave, ysave, xcur, ycur;
 
 	TAILQ_INIT(&resultq);
 
+	xu_ptr_get(sc->rootwin, &xsave, &ysave);
+
 	(void)memset(&mc, 0, sizeof(mc));
-
-	xu_ptr_getpos(sc->rootwin, &xsave, &ysave);
-
 	mc.sc = sc;
 	mc.flags = flags;
 	mc.match = match;
@@ -105,39 +108,41 @@ menu_filter(struct screen_ctx *sc, struct menu_q *menuq, const char *prompt,
 	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';
 
-	evmask = MENUMASK;
-	if (prompt != NULL) {
-		evmask |= KEYMASK; /* accept keys as well */
-		(void)strlcpy(mc.promptstr, prompt, sizeof(mc.promptstr));
-		mc.hasprompt = 1;
-	}
+	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, sc->menu.win, evmask);
-	XMapRaised(X_Dpy, sc->menu.win);
+	XSelectInput(X_Dpy, mc.win, MENUMASK);
+	XMapRaised(X_Dpy, mc.win);
 
-	if (XGrabPointer(X_Dpy, sc->menu.win, False, MENUGRABMASK,
+	if (XGrabPointer(X_Dpy, mc.win, False, MENUGRABMASK,
 	    GrabModeAsync, GrabModeAsync, None, Conf.cursor[CF_QUESTION],
 	    CurrentTime) != GrabSuccess) {
-		XUnmapWindow(X_Dpy, sc->menu.win);
-		return(NULL);
+		XftDrawDestroy(mc.xftdraw);
+		XDestroyWindow(X_Dpy, mc.win);
+		return NULL;
 	}
 
 	XGetInputFocus(X_Dpy, &focuswin, &focusrevert);
-	XSetInputFocus(X_Dpy, sc->menu.win, RevertToPointerRoot, CurrentTime);
+	XSetInputFocus(X_Dpy, mc.win, RevertToPointerRoot, CurrentTime);
 
 	/* make sure keybindings don't remove keys from the menu stream */
-	XGrabKeyboard(X_Dpy, sc->menu.win, True,
+	XGrabKeyboard(X_Dpy, mc.win, True,
 	    GrabModeAsync, GrabModeAsync, CurrentTime);
 
 	for (;;) {
 		mc.changed = 0;
 
-		XWindowEvent(X_Dpy, sc->menu.win, evmask, &e);
+		XWindowEvent(X_Dpy, mc.win, MENUMASK, &e);
 
 		switch (e.type) {
 		case KeyPress:
@@ -168,18 +173,19 @@ out:
 		mi = NULL;
 	}
 
+	XftDrawDestroy(mc.xftdraw);
+	XDestroyWindow(X_Dpy, mc.win);
+
 	XSetInputFocus(X_Dpy, focuswin, focusrevert, CurrentTime);
 	/* restore if user didn't move */
-	xu_ptr_getpos(sc->rootwin, &xcur, &ycur);
+	xu_ptr_get(sc->rootwin, &xcur, &ycur);
 	if (xcur == mc.geom.x && ycur == mc.geom.y)
-		xu_ptr_setpos(sc->rootwin, xsave, ysave);
-	XUngrabPointer(X_Dpy, CurrentTime);
+		xu_ptr_set(sc->rootwin, xsave, ysave);
 
-	XMoveResizeWindow(X_Dpy, sc->menu.win, 0, 0, 1, 1);
-	XUnmapWindow(X_Dpy, sc->menu.win);
+	XUngrabPointer(X_Dpy, CurrentTime);
 	XUngrabKeyboard(X_Dpy, CurrentTime);
 
-	return(mi);
+	return mi;
 }
 
 static struct menu *
@@ -188,13 +194,14 @@ 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,
-	    (CWM_MENU_DUMMY), search_match_path, search_print_text)) != NULL) {
+	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')
@@ -206,7 +213,7 @@ menu_complete_path(struct menu_ctx *mc)
 	
 	menuq_clear(&menuq);
 
-	return(mr);
+	return mr;
 }
 
 static struct menu *
@@ -221,7 +228,7 @@ menu_handle_key(XEvent *e, struct menu_ctx *mc, struct menu_q *menuq,
 	wchar_t 	 wc;
 
 	if (menu_keycode(&e->xkey, &ctl, chr) < 0)
-		return(NULL);
+		return NULL;
 
 	switch (ctl) {
 	case CTL_ERASEONE:
@@ -262,7 +269,7 @@ menu_handle_key(XEvent *e, struct menu_ctx *mc, struct menu_q *menuq,
 			mi->dummy = 1;
 		}
 		mi->abort = 0;
-		return(mi);
+		return mi;
 	case CTL_WIPE:
 		mc->searchstr[0] = '\0';
 		mc->changed = 1;
@@ -277,7 +284,7 @@ menu_handle_key(XEvent *e, struct menu_ctx *mc, struct menu_q *menuq,
 			if ((mc->flags & CWM_MENU_FILE) &&
 			    (strncmp(mc->searchstr, mi->text,
 					strlen(mi->text))) == 0)
-				return(menu_complete_path(mc));
+				return menu_complete_path(mc);
 
 			/*
 			 * Put common prefix of the results into searchstr
@@ -302,7 +309,7 @@ menu_handle_key(XEvent *e, struct menu_ctx *mc, struct menu_q *menuq,
 		mi->text[0] = '\0';
 		mi->dummy = 1;
 		mi->abort = 1;
-		return(mi);
+		return mi;
 	default:
 		break;
 	}
@@ -320,7 +327,7 @@ menu_handle_key(XEvent *e, struct menu_ctx *mc, struct menu_q *menuq,
 		mc->listing = 0;
 	}
 
-	return(NULL);
+	return NULL;
 }
 
 static void
@@ -343,34 +350,25 @@ menu_draw(struct menu_ctx *mc, struct menu_q *menuq, struct menu_q *resultq)
 			mc->listing = 0;
 	}
 
-	mc->num = 0;
-	mc->geom.w = 0;
-	mc->geom.h = 0;
-	if (mc->hasprompt) {
-		(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->height + 1;
-		mc->num = 1;
-	}
+	(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->height + 1;
+		mc->geom.h += sc->xftfont->ascent + sc->xftfont->descent;
 		mc->num++;
 	}
 
-	area = screen_area(sc, mc->geom.x, mc->geom.y, CWM_GAP);
+	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;
 
@@ -392,35 +390,32 @@ menu_draw(struct menu_ctx *mc, struct menu_q *menuq, struct menu_q *resultq)
 	}
 
 	if (mc->geom.x != xsave || mc->geom.y != ysave)
-		xu_ptr_setpos(sc->rootwin, mc->geom.x, mc->geom.y);
+		xu_ptr_set(sc->rootwin, mc->geom.x, mc->geom.y);
 
-	XClearWindow(X_Dpy, sc->menu.win);
-	XMoveResizeWindow(X_Dpy, sc->menu.win, 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 = 0;
-	if (mc->hasprompt) {
-		XftDrawStringUtf8(sc->menu.xftdraw,
-		    &sc->xftcolor[CWM_COLOR_MENU_FONT], sc->xftfont,
-		    0, sc->xftfont->ascent,
-		    (const FcChar8*)mc->dispstr, strlen(mc->dispstr));
-		n++;
-	}
+	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->height + 1) + sc->xftfont->ascent + 1;
+		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)
+		if (mc->geom.y + y >= area.h)
 			break;
 
-		XftDrawStringUtf8(sc->menu.xftdraw,
+		XftDrawStringUtf8(mc->xftdraw,
 		    &sc->xftcolor[CWM_COLOR_MENU_FONT], sc->xftfont,
-		    0, y,
+		    0, y + sc->xftfont->ascent,
 		    (const FcChar8*)mi->print, strlen(mi->print));
 		n++;
 	}
-	if (mc->hasprompt && n > 1)
+	if (n > 1)
 		menu_draw_entry(mc, resultq, 1, 1);
 }
 
@@ -430,10 +425,7 @@ menu_draw_entry(struct menu_ctx *mc, struct menu_q *resultq,
 {
 	struct screen_ctx	*sc = mc->sc;
 	struct menu		*mi;
-	int			 color, i = 0;
-
-	if (mc->hasprompt)
-		i = 1;
+	int			 color, i = 1, y;
 
 	TAILQ_FOREACH(mi, resultq, resultentry)
 		if (entry == i++)
@@ -441,14 +433,13 @@ menu_draw_entry(struct menu_ctx *mc, struct menu_q *resultq,
 	if (mi == NULL)
 		return;
 
+	y = entry * (sc->xftfont->ascent + sc->xftfont->descent);
 	color = (active) ? CWM_COLOR_MENU_FG : CWM_COLOR_MENU_BG;
-	XftDrawRect(sc->menu.xftdraw, &sc->xftcolor[color], 0,
-	    (sc->xftfont->height + 1) * entry, mc->geom.w,
-	    (sc->xftfont->height + 1) + sc->xftfont->descent);
+	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(sc->menu.xftdraw,
-	    &sc->xftcolor[color], sc->xftfont,
-	    0, (sc->xftfont->height + 1) * entry + sc->xftfont->ascent + 1,
+	XftDrawStringUtf8(mc->xftdraw,
+	    &sc->xftcolor[color], sc->xftfont, 0, y + sc->xftfont->ascent,
 	    (const FcChar8*)mi->print, strlen(mi->print));
 }
 
@@ -474,13 +465,10 @@ static struct menu *
 menu_handle_release(struct menu_ctx *mc, struct menu_q *resultq, int x, int y)
 {
 	struct menu		*mi;
-	int			 entry, i = 0;
+	int			 entry, i = 1;
 
 	entry = menu_calc_entry(mc, x, y);
 
-	if (mc->hasprompt)
-		i = 1;
-
 	TAILQ_FOREACH(mi, resultq, resultentry)
 		if (entry == i++)
 			break;
@@ -489,7 +477,7 @@ menu_handle_release(struct menu_ctx *mc, struct menu_q *resultq, int x, int y)
 		mi->text[0] = '\0';
 		mi->dummy = 1;
 	}
-	return(mi);
+	return mi;
 }
 
 static int
@@ -498,18 +486,18 @@ menu_calc_entry(struct menu_ctx *mc, int x, int y)
 	struct screen_ctx	*sc = mc->sc;
 	int			 entry;
 
-	entry = y / (sc->xftfont->height + 1);
+	entry = y / (sc->xftfont->ascent + sc->xftfont->descent);
 
 	/* in bounds? */
 	if (x < 0 || x > mc->geom.w || y < 0 ||
-	    y > (sc->xftfont->height + 1) * mc->num ||
+	    y > (sc->xftfont->ascent + sc->xftfont->descent) * mc->num ||
 	    entry < 0 || entry >= mc->num)
 		entry = -1;
 
-	if (mc->hasprompt && entry == 0)
+	if (entry == 0)
 		entry = -1;
 
-	return(entry);
+	return entry;
 }
 
 static int
@@ -592,12 +580,12 @@ menu_keycode(XKeyEvent *ev, enum ctltype *ctl, char *chr)
 	}
 
 	if (*ctl != CTL_NONE)
-		return(0);
+		return 0;
 
 	if (XLookupString(ev, chr, 32, &ks, NULL) < 0)
-		return(-1);
+		return -1;
 
-	return(0);
+	return 0;
 }
 
 void
@@ -629,34 +617,3 @@ menuq_clear(struct menu_q *mq)
 		free(mi);
 	}
 }
-
-void
-menu_windraw(struct screen_ctx *sc, Window win, const char *fmt, ...)
-{
-	va_list			 ap;
-	int			 i;
-	char			*text;
-	XGlyphInfo		 extents;
-
-	va_start(ap, fmt);
-	i = vasprintf(&text, fmt, ap);
-	va_end(ap);
-
-	if (i < 0 || text == NULL)
-		err(1, "vasprintf");
-
-	XftTextExtentsUtf8(X_Dpy, sc->xftfont, (const FcChar8*)text,
-	    strlen(text), &extents);
-
-	XReparentWindow(X_Dpy, sc->menu.win, win, 0, 0);
-	XMoveResizeWindow(X_Dpy, sc->menu.win, 0, 0,
-	    extents.xOff, sc->xftfont->height);
-	XMapWindow(X_Dpy, sc->menu.win);
-	XClearWindow(X_Dpy, sc->menu.win);
-
-	XftDrawStringUtf8(sc->menu.xftdraw, &sc->xftcolor[CWM_COLOR_MENU_FONT],
-	    sc->xftfont, 0, sc->xftfont->ascent + 1,
-	    (const FcChar8*)text, strlen(text));
-
-	free(text);
-}

parse.y

@@ -22,7 +22,7 @@
 %{
 
 #include <sys/types.h>
-#include <sys/queue.h>
+#include "queue.h"
 
 #include <ctype.h>
 #include <err.h>
@@ -45,7 +45,7 @@ static struct file {
 	int			 lineno;
 	int			 errors;
 } *file, *topfile;
-struct file	*pushfile(const char *);
+struct file	*pushfile(const char *, FILE *);
 int		 popfile(void);
 int		 yyparse(void);
 int		 yylex(void);
@@ -72,8 +72,8 @@ typedef struct {
 
 %token	BINDKEY UNBINDKEY BINDMOUSE UNBINDMOUSE
 %token	FONTNAME STICKY GAP
-%token	AUTOGROUP COMMAND IGNORE
-%token	YES NO BORDERWIDTH MOVEAMOUNT
+%token	AUTOGROUP COMMAND IGNORE WM
+%token	YES NO BORDERWIDTH MOVEAMOUNT HTILE VTILE
 %token	COLOR SNAPDIST
 %token	ACTIVEBORDER INACTIVEBORDER URGENCYBORDER
 %token	GROUPBORDER UNGROUPBORDER
@@ -83,7 +83,7 @@ typedef struct {
 %token	<v.string>		STRING
 %token	<v.number>		NUMBER
 %type	<v.number>		yesno
-%type	<v.string>		string
+%type	<v.string>		string numberstring
 %%
 
 grammar		: /* empty */
@@ -106,6 +106,17 @@ string		: string STRING			{
 		| STRING
 		;
 
+numberstring	: NUMBER				{
+			char	*s;
+			if (asprintf(&s, "%lld", $1) == -1) {
+				yyerror("string: asprintf");
+				YYERROR;
+			}
+			$$ = s;
+		}
+		| STRING
+		;
+
 yesno		: YES				{ $$ = 1; }
 		| NO				{ $$ = 0; }
 		;
@@ -124,6 +135,20 @@ main		: FONTNAME STRING		{
 			}
 			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");
@@ -139,12 +164,24 @@ main		: FONTNAME STRING		{
 			conf->snapdist = $2;
 		}
 		| COMMAND STRING string		{
-			if (!conf_cmd_add(conf, $2, $3)) {
-				yyerror("command name/path too long");
+			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);
 		}
@@ -185,7 +222,7 @@ main		: FONTNAME STRING		{
 			conf->gap.left = $4;
 			conf->gap.right = $5;
 		}
-		| BINDKEY STRING string {
+		| BINDKEY numberstring string {
 			if (!conf_bind_key(conf, $2, $3)) {
 				yyerror("invalid bind-key: %s %s", $2, $3);
 				free($2);
@@ -195,7 +232,7 @@ main		: FONTNAME STRING		{
 			free($2);
 			free($3);
 		}
-		| UNBINDKEY STRING {
+		| UNBINDKEY numberstring {
 			if (!conf_bind_key(conf, $2, NULL)) {
 				yyerror("invalid unbind-key: %s", $2);
 				free($2);
@@ -203,7 +240,7 @@ main		: FONTNAME STRING		{
 			}
 			free($2);
 		}
-		| BINDMOUSE STRING string {
+		| BINDMOUSE numberstring string {
 			if (!conf_bind_mouse(conf, $2, $3)) {
 				yyerror("invalid bind-mouse: %s %s", $2, $3);
 				free($2);
@@ -213,7 +250,7 @@ main		: FONTNAME STRING		{
 			free($2);
 			free($3);
 		}
-		| UNBINDMOUSE STRING {
+		| UNBINDMOUSE numberstring {
 			if (!conf_bind_mouse(conf, $2, NULL)) {
 				yyerror("invalid unbind-mouse: %s", $2);
 				free($2);
@@ -306,6 +343,7 @@ lookup(char *s)
 		{ "fontname",		FONTNAME},
 		{ "gap",		GAP},
 		{ "groupborder",	GROUPBORDER},
+		{ "htile",		HTILE},
 		{ "ignore",		IGNORE},
 		{ "inactiveborder",	INACTIVEBORDER},
 		{ "menubg",		MENUBG},
@@ -319,6 +357,8 @@ lookup(char *s)
 		{ "unbind-mouse",	UNBINDMOUSE},
 		{ "ungroupborder",	UNGROUPBORDER},
 		{ "urgencyborder",	URGENCYBORDER},
+		{ "vtile",		VTILE},
+		{ "wm",			WM},
 		{ "yes",		YES}
 	};
 	const struct keywords	*p;
@@ -347,7 +387,7 @@ lgetc(int quotec)
 	if (parsebuf) {
 		/* Read character from the parsebuffer instead of input. */
 		if (parseindex >= 0) {
-			c = parsebuf[parseindex++];
+			c = (unsigned char)parsebuf[parseindex++];
 			if (c != '\0')
 				return (c);
 			parsebuf = NULL;
@@ -356,7 +396,7 @@ lgetc(int quotec)
 	}
 
 	if (pushback_index)
-		return (pushback_buffer[--pushback_index]);
+		return ((unsigned char)pushback_buffer[--pushback_index]);
 
 	if (quotec) {
 		if ((c = getc(file->stream)) == EOF) {
@@ -397,10 +437,10 @@ lungetc(int c)
 		if (parseindex >= 0)
 			return (c);
 	}
-	if (pushback_index < MAXPUSHBACK-1)
-		return (pushback_buffer[pushback_index++] = c);
-	else
+	if (pushback_index + 1 >= MAXPUSHBACK)
 		return (EOF);
+	pushback_buffer[pushback_index++] = c;
+	return (c);
 }
 
 int
@@ -413,7 +453,7 @@ findeol(void)
 	/* skip to either EOF or the first real EOL */
 	while (1) {
 		if (pushback_index)
-			c = pushback_buffer[--pushback_index];
+			c = (unsigned char)pushback_buffer[--pushback_index];
 		else
 			c = lgetc(0);
 		if (c == '\n') {
@@ -456,7 +496,8 @@ yylex(void)
 			} else if (c == '\\') {
 				if ((next = lgetc(quotec)) == EOF)
 					return (0);
-				if (next == quotec || c == ' ' || c == '\t')
+				if (next == quotec || next == ' ' ||
+				    next == '\t')
 					c = next;
 				else if (next == '\n') {
 					file->lineno++;
@@ -486,7 +527,7 @@ yylex(void)
 	if (c == '-' || isdigit(c)) {
 		do {
 			*p++ = c;
-			if ((unsigned)(p-buf) >= sizeof(buf)) {
+			if ((size_t)(p-buf) >= sizeof(buf)) {
 				yyerror("string too long");
 				return (findeol());
 			}
@@ -509,8 +550,8 @@ yylex(void)
 		} else {
 nodigits:
 			while (p > buf + 1)
-				lungetc(*--p);
-			c = *--p;
+				lungetc((unsigned char)*--p);
+			c = (unsigned char)*--p;
 			if (c == '-')
 				return (c);
 		}
@@ -525,7 +566,7 @@ nodigits:
 	if (isalnum(c) || c == ':' || c == '_' || c == '*' || c == '/') {
 		do {
 			*p++ = c;
-			if ((unsigned)(p-buf) >= sizeof(buf)) {
+			if ((size_t)(p-buf) >= sizeof(buf)) {
 				yyerror("string too long");
 				return (findeol());
 			}
@@ -546,19 +587,13 @@ nodigits:
 }
 
 struct file *
-pushfile(const char *name)
+pushfile(const char *name, FILE *stream)
 {
 	struct file	*nfile;
 
 	nfile = xcalloc(1, sizeof(struct file));
 	nfile->name = xstrdup(name);
-
-	if ((nfile->stream = fopen(nfile->name, "r")) == NULL) {
-		warn("%s", nfile->name);
-		free(nfile->name);
-		free(nfile);
-		return (NULL);
-	}
+	nfile->stream = stream;
 	nfile->lineno = 1;
 	TAILQ_INSERT_TAIL(&files, nfile, entry);
 	return (nfile);
@@ -583,13 +618,19 @@ popfile(void)
 int
 parse_config(const char *filename, struct conf *xconf)
 {
+	FILE		*stream;
 	int		 errors = 0;
 
 	conf = xconf;
 
-	if ((file = pushfile(filename)) == NULL) {
+	stream = fopen(filename, "r");
+	if (stream == NULL) {
+		if (errno == ENOENT)
+			return (0);
+		warn("%s", filename);
 		return (-1);
 	}
+	file = pushfile(filename, stream);
 	topfile = file;
 
 	yyparse();

screen.c

@@ -24,6 +24,7 @@
 #include <err.h>
 #include <errno.h>
 #include <limits.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -31,13 +32,14 @@
 
 #include "calmwm.h"
 
+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;
-	Window			*wins, w0, w1, active = None;
-	XSetWindowAttributes	 rootattr;
-	unsigned int		 nwins, i;
+	XSetWindowAttributes	 attr;
 
 	sc = xmalloc(sizeof(*sc));
 
@@ -47,6 +49,8 @@ screen_init(int which)
 
 	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;
 
@@ -55,43 +59,54 @@ screen_init(int which)
 	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);
 
-	for (i = 0; i < Conf.ngroups; i++)
-		group_init(sc, i);
-
 	xu_ewmh_net_desktop_names(sc);
-	xu_ewmh_net_wm_desktop_viewport(sc);
-	xu_ewmh_net_wm_number_of_desktops(sc);
+	xu_ewmh_net_number_of_desktops(sc);
 	xu_ewmh_net_showing_desktop(sc);
 	xu_ewmh_net_virtual_roots(sc);
-	active = xu_ewmh_get_net_active_window(sc);
 
-	rootattr.cursor = Conf.cursor[CF_NORMAL];
-	rootattr.event_mask = SubstructureRedirectMask |
-	    SubstructureNotifyMask | PropertyChangeMask | EnterWindowMask |
-	    LeaveWindowMask | ColormapChangeMask | BUTTONMASK;
-
-	XChangeWindowAttributes(X_Dpy, sc->rootwin,
-	    (CWEventMask | CWCursor), &rootattr);
-
-	/* Deal with existing clients. */
-	if (XQueryTree(X_Dpy, sc->rootwin, &w0, &w1, &wins, &nwins)) {
-		for (i = 0; i < nwins; i++)
-			(void)client_init(wins[i], sc, (active == wins[i]));
-
-		XFree(wins);
-	}
-	screen_updatestackingorder(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
+screen_scan(struct screen_ctx *sc)
+{
+	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_find(Window win)
 {
@@ -99,10 +114,10 @@ screen_find(Window win)
 
 	TAILQ_FOREACH(sc, &Screenq, entry) {
 		if (sc->rootwin == win)
-			return(sc);
+			return sc;
 	}
-	warnx("%s: failure win 0x%lu\n", __func__, win);
-	return(NULL);
+	warnx("%s: failure win 0x%lx", __func__, win);
+	return NULL;
 }
 
 void
@@ -136,25 +151,25 @@ region_find(struct screen_ctx *sc, int x, int y)
 			break;
 		}
 	}
-	return(rc);
+	return rc;
 }
 
 struct geom
-screen_area(struct screen_ctx *sc, int x, int y, enum apply_gap apply_gap)
+screen_area(struct screen_ctx *sc, int x, int y, int apply_gap)
 {
 	struct region_ctx	*rc;
-	struct geom		 area = sc->work;
+	struct geom		 area = sc->view;
 
 	TAILQ_FOREACH(rc, &sc->regionq, entry) {
-		if ((x >= rc->area.x) && (x < (rc->area.x + rc->area.w)) &&
-		    (y >= rc->area.y) && (y < (rc->area.y + rc->area.h))) {
-			area = rc->area;
+		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);
+	return area;
 }
 
 void
@@ -190,10 +205,6 @@ screen_update_geometry(struct screen_ctx *sc)
 
 			rc = xmalloc(sizeof(*rc));
 			rc->num = i;
-			rc->area.x = ci->x;
-			rc->area.y = ci->y;
-			rc->area.w = ci->width;
-			rc->area.h = ci->height;
 			rc->view.x = ci->x;
 			rc->view.y = ci->y;
 			rc->view.w = ci->width;
@@ -216,10 +227,11 @@ screen_update_geometry(struct screen_ctx *sc)
 	}
 
 	xu_ewmh_net_desktop_geometry(sc);
+	xu_ewmh_net_desktop_viewport(sc);
 	xu_ewmh_net_workarea(sc);
 }
 
-struct geom
+static struct geom
 screen_apply_gap(struct screen_ctx *sc, struct geom geom)
 {
 	geom.x += sc->gap.left;
@@ -227,7 +239,7 @@ screen_apply_gap(struct screen_ctx *sc, struct geom geom)
 	geom.w -= (sc->gap.left + sc->gap.right);
 	geom.h -= (sc->gap.top + sc->gap.bottom);
 
-	return(geom);
+	return geom;
 }
 
 /* Bring back clients which are beyond the screen. */
@@ -252,3 +264,44 @@ screen_assert_clients_within(struct screen_ctx *sc)
 		}
 	}
 }
+
+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);
+
+	XMapWindow(X_Dpy, sc->prop.win);
+}
+
+void
+screen_prop_win_destroy(struct screen_ctx *sc)
+{
+	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

@@ -36,40 +36,66 @@
 #define PATH_ANY 	0x0001
 #define PATH_EXEC 	0x0002
 
-static void	search_match_path_type(struct menu_q *, struct menu_q *,
-		    char *, int);
-static int	strsubmatch(char *, char *, int);
+static void	match_path_type(struct menu_q *, char *, int);
+static int	match_substr(char *, char *, int);
+
+static int
+match_substr(char *sub, char *str, int zeroidx)
+{
+	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;
+}
 
 void
 search_match_client(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct winname	*wn;
-	struct menu	*mi, *tierp[4], *before = NULL;
-
-	TAILQ_INIT(resultq);
+	struct menu		*mi, *tierp[3], *before = NULL;
+	struct client_ctx	*cc;
+	struct winname		*wn;
 
 	(void)memset(tierp, 0, sizeof(tierp));
 
+	TAILQ_INIT(resultq);
 	TAILQ_FOREACH(mi, menuq, entry) {
 		int tier = -1, t;
-		struct client_ctx *cc = (struct client_ctx *)mi->ctx;
+		cc = (struct client_ctx *)mi->ctx;
 
 		/* Match on label. */
-		if (strsubmatch(search, cc->label, 0))
+		if (match_substr(search, cc->label, 0))
 			tier = 0;
 
 		/* Match on window name history, from present to past. */
 		if (tier < 0) {
 			TAILQ_FOREACH_REVERSE(wn, &cc->nameq, name_q, entry)
-				if (strsubmatch(search, wn->name, 0)) {
-					tier = 2;
+				if (match_substr(search, wn->name, 0)) {
+					tier = 1;
 					break;
 				}
 		}
 
 		/* Match on window resource class. */
-		if ((tier < 0) && strsubmatch(search, cc->ch.res_class, 0))
-			tier = 3;
+		if ((tier < 0) && match_substr(search, cc->res_class, 0))
+			tier = 2;
 
 		if (tier < 0)
 			continue;
@@ -82,9 +108,6 @@ search_match_client(struct menu_q *menuq, struct menu_q *resultq, char *search)
 		if ((tier > 0) && (cc->flags & CLIENT_HIDDEN))
 			tier--;
 
-		if (tier >= nitems(tierp))
-			errx(1, "%s: invalid tier", __func__);
-
 		/*
 		 * If you have a tierp, insert after it, and make it
 		 * the new tierp.  If you don't have a tierp, find the
@@ -105,27 +128,115 @@ search_match_client(struct menu_q *menuq, struct menu_q *resultq, char *search)
 }
 
 void
-search_print_text(struct menu *mi, int listing)
+search_match_cmd(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	(void)snprintf(mi->print, sizeof(mi->print), "%s", mi->text);
+	struct menu		*mi;
+	struct cmd_ctx		*cmd;
+
+	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_print_cmd(struct menu *mi, int listing)
+search_match_group(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct cmd_ctx	*cmd = (struct cmd_ctx *)mi->ctx;
+	struct menu		*mi;
+	struct group_ctx	*gc;
+	char			*s;
 
-	(void)snprintf(mi->print, sizeof(mi->print), "%s", cmd->name);
+	TAILQ_INIT(resultq);
+	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_print_group(struct menu *mi, int listing)
+search_match_exec(struct menu_q *menuq, struct menu_q *resultq, char *search)
 {
-	struct group_ctx	*gc = (struct group_ctx *)mi->ctx;
+	struct menu	*mi, *mj;
+	int		 r;
 
-	(void)snprintf(mi->print, sizeof(mi->print),
-	    (group_holds_only_hidden(gc)) ? "%d: [%s]" : "%d: %s",
-	    gc->num, gc->name);
+	TAILQ_INIT(resultq);
+	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_match_path(struct menu_q *menuq, struct menu_q *resultq, char *search)
+{
+	TAILQ_INIT(resultq);
+	match_path_type(resultq, search, PATH_ANY);
+}
+
+void
+search_match_text(struct menu_q *menuq, struct menu_q *resultq, char *search)
+{
+	struct menu	*mi;
+
+	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
@@ -144,100 +255,35 @@ search_print_client(struct menu *mi, int listing)
 	    (cc->label) ? cc->label : "", cc->name);
 }
 
-static void
-search_match_path_type(struct menu_q *menuq, struct menu_q *resultq,
-    char *search, int flag)
+void
+search_print_cmd(struct menu *mi, int listing)
 {
-	struct menu     *mi;
-	char 		 pattern[PATH_MAX];
-	glob_t		 g;
-	int		 i;
+	struct cmd_ctx		*cmd = (struct cmd_ctx *)mi->ctx;
 
-	(void)strlcpy(pattern, search, sizeof(pattern));
-	(void)strlcat(pattern, "*", sizeof(pattern));
-
-	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);
+	(void)snprintf(mi->print, sizeof(mi->print), "%s", cmd->name);
 }
 
 void
-search_match_path(struct menu_q *menuq, struct menu_q *resultq, char *search)
+search_print_group(struct menu *mi, int listing)
 {
-	TAILQ_INIT(resultq);
+	struct group_ctx	*gc = (struct group_ctx *)mi->ctx;
 
-	search_match_path_type(menuq, resultq, search, PATH_ANY);
+	(void)snprintf(mi->print, sizeof(mi->print),
+	    (group_holds_only_hidden(gc)) ? "%d: [%s]" : "%d: %s",
+	    gc->num, gc->name);
 }
 
 void
-search_match_text(struct menu_q *menuq, struct menu_q *resultq, char *search)
+search_print_text(struct menu *mi, int listing)
 {
-	struct menu	*mi;
-
-	TAILQ_INIT(resultq);
-
-	TAILQ_FOREACH(mi, menuq, entry)
-		if (strsubmatch(search, mi->text, 0))
-			TAILQ_INSERT_TAIL(resultq, mi, resultentry);
+	(void)snprintf(mi->print, sizeof(mi->print), "%s", mi->text);
 }
 
 void
-search_match_exec(struct menu_q *menuq, struct menu_q *resultq, char *search)
+search_print_wm(struct menu *mi, int listing)
 {
-	struct menu	*mi, *mj;
-	int		 r;
+	struct cmd_ctx		*wm = (struct cmd_ctx *)mi->ctx;
 
-	TAILQ_INIT(resultq);
-
-	TAILQ_FOREACH(mi, menuq, entry) {
-		if (strsubmatch(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))
-		search_match_path_type(menuq, resultq, search, PATH_EXEC);
-}
-
-static int
-strsubmatch(char *sub, char *str, int zeroidx)
-{
-	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 = len - sublen;
-	else
-		flen = 0;
-
-	for (n = 0; n <= flen; n++)
-		if (strncasecmp(sub, str + n, sublen) == 0)
-			return(1);
-
-	return(0);
+	(void)snprintf(mi->print, sizeof(mi->print), "%s [%s]",
+	    wm->name, wm->path);
 }

util.c

@@ -24,6 +24,7 @@
 #include <err.h>
 #include <errno.h>
 #include <limits.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -31,13 +32,15 @@
 
 #include "calmwm.h"
 
+static void	 log_msg(const char *, va_list);
+
 void
 u_spawn(char *argstr)
 {
 	switch (fork()) {
 	case 0:
 		u_exec(argstr);
-		break;
+		exit(1);
 	case -1:
 		warn("fork");
 	default:
@@ -50,7 +53,7 @@ u_exec(char *argstr)
 {
 #define MAXARGLEN 20
 	char	*args[MAXARGLEN], **ap = args;
-	char	**end = &args[MAXARGLEN - 1], *tmp;
+	char	**end = &args[MAXARGLEN - 2], *tmp;
 	char	*s = argstr;
 
 	while (ap < end && (*ap = strsep(&argstr, " \t")) != NULL) {
@@ -78,7 +81,7 @@ u_exec(char *argstr)
 
 	(void)setsid();
 	(void)execvp(args[0], args);
-	err(1, "%s", s);
+	warn("%s", s);
 }
 
 char *
@@ -89,12 +92,12 @@ u_argv(char * const *argv)
 	char	*p;
 
 	if (argv == 0)
-		return(NULL);
+		return NULL;
 
 	for (i = 0; argv[i]; i++)
 		siz += strlen(argv[i]) + 1;
 	if (siz == 0)
-		return(NULL);
+		return NULL;
 
 	p = xmalloc(siz);
 	strlcpy(p, argv[0], siz);
@@ -102,5 +105,36 @@ u_argv(char * const *argv)
 		strlcat(p, " ", siz);
 		strlcat(p, argv[i], siz);
 	}
-	return(p);
+	return p;
+}
+
+static void
+log_msg(const char *msg, va_list ap)
+{
+	char	*fmt;
+
+	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

@@ -69,22 +69,28 @@ void		(*xev_handlers[LASTEvent])(XEvent *) = {
 };
 
 static KeySym modkeys[] = { XK_Alt_L, XK_Alt_R, XK_Super_L, XK_Super_R,
-			    XK_Control_L, XK_Control_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;
+	struct screen_ctx	*sc;
+	struct client_ctx	*cc, *old_cc;
 
-	if ((old_cc = client_current()) != NULL)
-		client_ptrsave(old_cc);
+	LOG_DEBUG3("parent: 0x%lx window: 0x%lx", e->parent, e->window);
+
+	if ((sc = screen_find(e->parent)) == NULL)
+		return;
+
+	if ((old_cc = client_current(sc)) != NULL)
+		client_ptr_save(old_cc);
 
 	if ((cc = client_find(e->window)) == NULL)
-		cc = client_init(e->window, NULL, 0);
+		cc = client_init(e->window, NULL);
 
 	if ((cc != NULL) && (!(cc->flags & CLIENT_IGNORE)))
-		client_ptrwarp(cc);
+		client_ptr_warp(cc);
 }
 
 static void
@@ -93,12 +99,14 @@ xev_handle_unmapnotify(XEvent *ee)
 	XUnmapEvent		*e = &ee->xunmap;
 	struct client_ctx	*cc;
 
+	LOG_DEBUG3("window: 0x%lx", e->window);
+
 	if ((cc = client_find(e->window)) != NULL) {
 		if (e->send_event) {
-			client_set_wm_state(cc, WithdrawnState);
+			xu_set_wm_state(cc->win, WithdrawnState);
 		} else {
 			if (!(cc->flags & CLIENT_HIDDEN))
-				client_delete(cc);
+				client_remove(cc);
 		}
 	}
 }
@@ -109,8 +117,10 @@ xev_handle_destroynotify(XEvent *ee)
 	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);
+		client_remove(cc);
 }
 
 static void
@@ -121,6 +131,8 @@ xev_handle_configurerequest(XEvent *ee)
 	struct screen_ctx	*sc;
 	XWindowChanges		 wc;
 
+	LOG_DEBUG3("window: 0x%lx", e->window);
+
 	if ((cc = client_find(e->window)) != NULL) {
 		sc = cc->sc;
 
@@ -174,13 +186,15 @@ xev_handle_propertynotify(XEvent *ee)
 	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) {
 		case XA_WM_NORMAL_HINTS:
-			client_getsizehints(cc);
+			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);
@@ -188,17 +202,19 @@ xev_handle_propertynotify(XEvent *ee)
 			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 {
-		TAILQ_FOREACH(sc, &Screenq, entry) {
-			if (sc->rootwin == e->window) {
-				if (e->atom == ewmh[_NET_DESKTOP_NAMES])
-					xu_ewmh_net_desktop_names(sc);
-			}
+		if (e->atom == ewmh[_NET_DESKTOP_NAMES])  {
+			if ((sc = screen_find(e->window)) != NULL)
+				xu_ewmh_net_desktop_names(sc);
 		}
 	}
 }
@@ -209,10 +225,12 @@ xev_handle_enternotify(XEvent *ee)
 	XCrossingEvent		*e = &ee->xcrossing;
 	struct client_ctx	*cc;
 
+	LOG_DEBUG3("window: 0x%lx", e->window);
+
 	Last_Event_Time = e->time;
 
 	if ((cc = client_find(e->window)) != NULL)
-		client_setactive(cc);
+		client_set_active(cc);
 }
 
 static void
@@ -223,28 +241,29 @@ xev_handle_buttonpress(XEvent *ee)
 	struct screen_ctx	*sc;
 	struct bind_ctx		*mb;
 
+	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;
+
 	e->state &= ~IGNOREMODMASK;
 
 	TAILQ_FOREACH(mb, &Conf.mousebindq, entry) {
 		if (e->button == mb->press.button && e->state == mb->modmask)
 			break;
 	}
-
 	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()) == NULL)
+		    ((cc = client_current(sc)) == NULL))
 			return;
 		(*mb->callback)(cc, mb->cargs);
 		break;
 	case CWM_CONTEXT_SC:
-		if (e->window != e->root)
-			return;
-		if ((sc = screen_find(e->window)) == NULL)
-			return;
 		(*mb->callback)(sc, mb->cargs);
 		break;
 	case CWM_CONTEXT_NONE:
@@ -259,9 +278,14 @@ xev_handle_buttonrelease(XEvent *ee)
 	XButtonEvent		*e = &ee->xbutton;
 	struct client_ctx	*cc;
 
+	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)
-			group_toggle_membership_leave(cc);
+		if (cc->flags & (CLIENT_ACTIVE | CLIENT_HIGHLIGHT)) {
+			cc->flags &= ~CLIENT_HIGHLIGHT;
+			client_draw_border(cc);
+		}
 	}
 }
 
@@ -275,6 +299,12 @@ xev_handle_keypress(XEvent *ee)
 	KeySym			 keysym, skeysym;
 	unsigned int		 modshift;
 
+	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);
 
@@ -292,20 +322,17 @@ xev_handle_keypress(XEvent *ee)
 		if (kb->press.keysym == ((modshift == 0) ? keysym : skeysym))
 			break;
 	}
-
 	if (kb == NULL)
 		return;
 	kb->cargs->xev = CWM_XEV_KEY;
 	switch (kb->context) {
 	case CWM_CONTEXT_CC:
-		if (((cc = client_find(e->window)) == NULL) &&
-		    (cc = client_current()) == NULL)
+		if (((cc = client_find(e->subwindow)) == NULL) &&
+		    ((cc = client_current(sc)) == NULL))
 			return;
 		(*kb->callback)(cc, kb->cargs);
 		break;
 	case CWM_CONTEXT_SC:
-		if ((sc = screen_find(e->window)) == NULL)
-			return;
 		(*kb->callback)(sc, kb->cargs);
 		break;
 	case CWM_CONTEXT_NONE:
@@ -322,16 +349,30 @@ xev_handle_keyrelease(XEvent *ee)
 {
 	XKeyEvent		*e = &ee->xkey;
 	struct screen_ctx	*sc;
+	struct client_ctx	*cc;
 	KeySym			 keysym;
 	unsigned int		 i;
 
+	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]) {
-			client_cycle_leave(sc);
+			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;
 		}
 	}
@@ -344,6 +385,8 @@ xev_handle_clientmessage(XEvent *ee)
 	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)
@@ -351,17 +394,14 @@ xev_handle_clientmessage(XEvent *ee)
 		}
 	} else if (e->message_type == ewmh[_NET_CLOSE_WINDOW]) {
 		if ((cc = client_find(e->window)) != NULL) {
-			client_send_delete(cc);
+			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)
-				client_ptrsave(old_cc);
-			if (cc->flags & CLIENT_HIDDEN)
-				client_unhide(cc);
-			else
-				client_raise(cc);
-			client_ptrwarp(cc);
+			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) {
@@ -373,7 +413,9 @@ xev_handle_clientmessage(XEvent *ee)
 			if (e->data.l[0] == (unsigned long)-1)
 				group_movetogroup(cc, 0);
 			else
-				group_movetogroup(cc, e->data.l[0]);
+				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) {
@@ -382,7 +424,9 @@ xev_handle_clientmessage(XEvent *ee)
 		}
 	} else if (e->message_type == ewmh[_NET_CURRENT_DESKTOP]) {
 		if ((sc = screen_find(e->window)) != NULL) {
-			group_only(sc, e->data.l[0]);
+			if (e->data.l[0] >= 0 &&
+			    e->data.l[0] < Conf.ngroups)
+				group_only(sc, e->data.l[0]);
 		}
 	}
 }
@@ -390,18 +434,17 @@ xev_handle_clientmessage(XEvent *ee)
 static void
 xev_handle_randr(XEvent *ee)
 {
-	XRRScreenChangeNotifyEvent	*rev = (XRRScreenChangeNotifyEvent *)ee;
+	XRRScreenChangeNotifyEvent	*e = (XRRScreenChangeNotifyEvent *)ee;
 	struct screen_ctx		*sc;
-	int				 i;
 
-	i = XRRRootToScreen(X_Dpy, rev->root);
-	TAILQ_FOREACH(sc, &Screenq, entry) {
-		if (sc->which == i) {
-			XRRUpdateConfiguration(ee);
-			screen_update_geometry(sc);
-			screen_assert_clients_within(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);
 }
 
 /*
@@ -414,6 +457,8 @@ 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)
@@ -427,6 +472,8 @@ 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);
 }
@@ -436,9 +483,11 @@ xev_process(void)
 {
 	XEvent		 e;
 
-	XNextEvent(X_Dpy, &e);
-	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);
+	while (XPending(X_Dpy)) {
+		XNextEvent(X_Dpy, &e);
+		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);
+	}
 }

xmalloc.c

@@ -43,7 +43,7 @@ xmalloc(size_t siz)
 	if ((p = malloc(siz)) == NULL)
 		err(1, "malloc");
 
-	return(p);
+	return p;
 }
 
 void *
@@ -58,7 +58,7 @@ xcalloc(size_t no, size_t siz)
 	if ((p = calloc(no, siz)) == NULL)
 		err(1, "calloc");
 
-	return(p);
+	return p;
 }
 
 void *
@@ -70,7 +70,7 @@ xreallocarray(void *ptr, size_t nmemb, size_t size)
 	if (p == NULL)
 		errx(1, "xreallocarray: out of memory (new_size %zu bytes)",
 		    nmemb * size);
-	return(p);
+	return p;
 }
 
 char *
@@ -81,7 +81,7 @@ xstrdup(const char *str)
 	if ((p = strdup(str)) == NULL)
 		err(1, "strdup");
 
-	return(p);
+	return p;
 }
 
 int
@@ -91,11 +91,20 @@ xasprintf(char **ret, const char *fmt, ...)
 	int	 i;
 
 	va_start(ap, fmt);
-	i = vasprintf(ret, fmt, ap);
+	i = xvasprintf(ret, fmt, ap);
 	va_end(ap);
 
-	if (i < 0 || *ret == NULL)
-		err(1, "asprintf");
-
-	return(i);
+	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

@@ -32,7 +32,7 @@
 #include "calmwm.h"
 
 void
-xu_ptr_getpos(Window win, int *x, int *y)
+xu_ptr_get(Window win, int *x, int *y)
 {
 	Window		 w0, w1;
 	int		 tmp0, tmp1;
@@ -42,13 +42,13 @@ xu_ptr_getpos(Window win, int *x, int *y)
 }
 
 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);
 }
 
 int
-xu_getprop(Window win, Atom atm, Atom type, long len, unsigned char **p)
+xu_get_prop(Window win, Atom atm, Atom type, long len, unsigned char **p)
 {
 	Atom		 realtype;
 	unsigned long	 n, extra;
@@ -56,16 +56,16 @@ xu_getprop(Window win, Atom atm, Atom type, long len, unsigned char **p)
 
 	if (XGetWindowProperty(X_Dpy, win, atm, 0L, len, False, type,
 	    &realtype, &format, &n, &extra, p) != Success || *p == NULL)
-		return(-1);
+		return -1;
 
 	if (n == 0)
 		XFree(*p);
 
-	return(n);
+	return n;
 }
 
 int
-xu_getstrprop(Window win, Atom atm, char **text) {
+xu_get_strprop(Window win, Atom atm, char **text) {
 	XTextProperty	 prop;
 	char		**list;
 	int		 nitems = 0;
@@ -73,8 +73,10 @@ xu_getstrprop(Window win, Atom atm, char **text) {
 	*text = NULL;
 
 	XGetTextProperty(X_Dpy, win, &prop, atm);
-	if (!prop.nitems)
-		return(0);
+	if (!prop.nitems) {
+		XFree(prop.value);
+		return 0;
+	}
 
 	if (Xutf8TextPropertyToTextList(X_Dpy, &prop, &list,
 	    &nitems) == Success && nitems > 0 && *list) {
@@ -90,10 +92,101 @@ xu_getstrprop(Window win, Atom atm, char **text) {
 		}
 		XFreeStringList(list);
 	}
-
 	XFree(prop.value);
 
-	return(nitems);
+	return nitems;
+}
+
+void
+xu_send_clientmsg(Window win, Atom proto, Time ts)
+{
+	XClientMessageEvent	 cm;
+
+	(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;
+
+	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 */
@@ -128,6 +221,16 @@ xu_ewmh_net_desktop_geometry(struct screen_ctx *sc)
 	    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)
 {
@@ -195,34 +298,8 @@ xu_ewmh_net_active_window(struct screen_ctx *sc, Window w)
 	    XA_WINDOW, 32, PropModeReplace, (unsigned char *)&w, 1);
 }
 
-Window
-xu_ewmh_get_net_active_window(struct screen_ctx *sc)
-{
-	long		*p;
-	Window		 win;
-
-	if ((xu_getprop(sc->rootwin, ewmh[_NET_ACTIVE_WINDOW],
-	    XA_WINDOW, 32, (unsigned char **)&p)) <= 0)
-		return(None);
-
-	win = (Window)*p;
-	XFree(p);
-
-	return(win);
-}
-
 void
-xu_ewmh_net_wm_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_wm_number_of_desktops(struct screen_ctx *sc)
+xu_ewmh_net_number_of_desktops(struct screen_ctx *sc)
 {
 	long	 ndesks = Conf.ngroups;
 
@@ -270,7 +347,7 @@ xu_ewmh_net_desktop_names(struct screen_ctx *sc)
 
 	/* Let group names be overwritten if _NET_DESKTOP_NAMES is set. */
 
-	if ((j = xu_getprop(sc->rootwin, ewmh[_NET_DESKTOP_NAMES],
+	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) {
@@ -312,8 +389,21 @@ xu_ewmh_net_desktop_names(struct screen_ctx *sc)
 }
 
 /* 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_net_wm_desktop(struct client_ctx *cc)
+xu_ewmh_set_net_wm_desktop(struct client_ctx *cc)
 {
 	long	 num = 0xffffffff;
 
@@ -329,15 +419,15 @@ xu_ewmh_get_net_wm_state(struct client_ctx *cc, int *n)
 {
 	Atom	*state, *p = NULL;
 
-	if ((*n = xu_getprop(cc->win, ewmh[_NET_WM_STATE], XA_ATOM, 64L,
+	if ((*n = xu_get_prop(cc->win, ewmh[_NET_WM_STATE], XA_ATOM, 64L,
 	    (unsigned char **)&p)) <= 0)
-		return(NULL);
+		return NULL;
 
 	state = xreallocarray(NULL, *n, sizeof(Atom));
 	(void)memcpy(state, p, *n * sizeof(Atom));
 	XFree((char *)p);
 
-	return(state);
+	return state;
 }
 
 void
@@ -345,9 +435,9 @@ xu_ewmh_handle_net_wm_state_msg(struct client_ctx *cc, int action,
     Atom first, Atom second)
 {
 	unsigned int i;
-	static struct handlers {
-		int atom;
-		int property;
+	struct handlers {
+		Atom atom;
+		int flag;
 		void (*toggle)(struct client_ctx *);
 	} handlers[] = {
 		{ _NET_WM_STATE_STICKY,
@@ -368,6 +458,12 @@ xu_ewmh_handle_net_wm_state_msg(struct client_ctx *cc, int action,
 		{ _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 },
@@ -379,11 +475,11 @@ xu_ewmh_handle_net_wm_state_msg(struct client_ctx *cc, int action,
 			continue;
 		switch (action) {
 		case _NET_WM_STATE_ADD:
-			if (!(cc->flags & handlers[i].property))
+			if (!(cc->flags & handlers[i].flag))
 				handlers[i].toggle(cc);
 			break;
 		case _NET_WM_STATE_REMOVE:
-			if (cc->flags & handlers[i].property)
+			if (cc->flags & handlers[i].flag)
 				handlers[i].toggle(cc);
 			break;
 		case _NET_WM_STATE_TOGGLE:
@@ -412,6 +508,10 @@ xu_ewmh_restore_net_wm_state(struct client_ctx *cc)
 			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);
 	}
@@ -433,6 +533,8 @@ xu_ewmh_set_net_wm_state(struct client_ctx *cc)
 		    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];
 	}
@@ -451,6 +553,10 @@ xu_ewmh_set_net_wm_state(struct client_ctx *cc)
 	}
 	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)
@@ -460,13 +566,3 @@ xu_ewmh_set_net_wm_state(struct client_ctx *cc)
 		XDeleteProperty(X_Dpy, cc->win, ewmh[_NET_WM_STATE]);
 	free(atoms);
 }
-
-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;
-}