X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=92145c4facb165fb449364fa211b718779c9881a;hb=4a043e85195b7337a6087d38d0c6c5c6817f187f;hp=10e725b9a82aa8f3b7a0fa37cf811b740699265f;hpb=e466d899cfdd58ccc2bf6164b1ea0f3d2b1749f5;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index 10e725b..92145c4 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -1,10 +1,11 @@
-/* $scrotwm$ */
 /*
- * Copyright (c) 2009-2010-2011 Marco Peereboom <marco@peereboom.us>
- * Copyright (c) 2009-2010-2011 Ryan McBride <mcbride@countersiege.com>
+ * Copyright (c) 2009-2012 Marco Peereboom <marco@peereboom.us>
+ * Copyright (c) 2009-2011 Ryan McBride <mcbride@countersiege.com>
  * Copyright (c) 2009 Darrin Chandler <dwchandler@stilyagin.com>
  * Copyright (c) 2009 Pierre-Yves Ritschard <pyr@spootnik.org>
+ * Copyright (c) 2010 Tuukka Kataja <stuge@xor.fi>
  * Copyright (c) 2011 Jason L. Wright <jason@thought.net>
+ * Copyright (c) 2011-2012 Reginald Kennedy <rk@rejii.com>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -51,10 +52,6 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-static const char	*cvstag = "$scrotwm$";
-
-#define	SWM_VERSION	"0.9.30"
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <err.h>
@@ -85,11 +82,20 @@ static const char	*cvstag = "$scrotwm$";
 #include <X11/Xproto.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrandr.h>
+#include <X11/extensions/XTest.h>
 
 #ifdef __OSX__
 #include <osx.h>
 #endif
 
+#include "version.h"
+
+#ifdef SCROTWM_BUILDSTR
+static const char	*buildstr = SCROTWM_BUILDSTR;
+#else
+static const char	*buildstr = SCROTWM_VERSION;
+#endif
+
 #if RANDR_MAJOR < 1
 #  error XRandR versions less than 1.0 are not supported
 #endif
@@ -160,6 +166,9 @@ u_int32_t		swm_debug = 0
 #define SWM_FOCUS_SYNERGY	(1)
 #define SWM_FOCUS_FOLLOW	(2)
 
+#define SWM_CONF_DEFAULT	(0)
+#define SWM_CONF_KEYMAPPING	(1)
+
 #ifndef SWM_LIB
 #define SWM_LIB			"/usr/local/lib/libswmhack.so"
 #endif
@@ -170,6 +179,7 @@ Atom			aprot;
 Atom			adelete;
 Atom			takefocus;
 Atom			a_wmname;
+Atom			a_netwmname;
 Atom			a_utf8_string;
 Atom			a_string;
 Atom			a_swm_iconic;
@@ -197,11 +207,35 @@ int			select_list_pipe[2];
 int			select_resp_pipe[2];
 pid_t			searchpid;
 volatile sig_atomic_t	search_resp;
+int			search_resp_action;
+
+struct search_window {
+	TAILQ_ENTRY(search_window)	entry;
+	int					idx;
+	struct ws_win		*win;
+	Window				indicator;
+};
+TAILQ_HEAD(search_winlist, search_window);
+
+struct search_winlist search_wl;
+
+/* search actions */
+enum {
+	SWM_SEARCH_NONE,
+	SWM_SEARCH_UNICONIFY,
+	SWM_SEARCH_NAME_WORKSPACE,
+	SWM_SEARCH_SEARCH_WORKSPACE,
+	SWM_SEARCH_SEARCH_WINDOW
+};
 
 /* dialog windows */
 double			dialog_ratio = .6;
 /* status bar */
-#define SWM_BAR_MAX	(256)
+#define SWM_BAR_MAX		(256)
+#define SWM_BAR_JUSTIFY_LEFT	(0)
+#define SWM_BAR_JUSTIFY_CENTER	(1)
+#define SWM_BAR_JUSTIFY_RIGHT	(2)
+#define SWM_BAR_OFFSET		(4)
 char			*bar_argv[] = { NULL, NULL };
 int			bar_pipe[2];
 char			bar_ext[SWM_BAR_MAX];
@@ -216,8 +250,10 @@ int			bar_extra = 1;
 int			bar_extra_running = 0;
 int			bar_verbose = 1;
 int			bar_height = 0;
+int			bar_justify = SWM_BAR_JUSTIFY_LEFT;
 int			stack_enabled = 1;
 int			clock_enabled = 1;
+int			urgent_enabled = 0;
 char			*clock_format = NULL;
 int			title_name_enabled = 0;
 int			title_class_enabled = 0;
@@ -225,6 +261,7 @@ int			window_name_enabled = 0;
 int			focus_mode = SWM_FOCUS_DEFAULT;
 int			disable_border = 0;
 int			border_width = 1;
+int			verbose_layout = 0;
 pid_t			bar_pid;
 GC			bar_gc;
 XGCValues		bar_gcv;
@@ -232,6 +269,7 @@ int			bar_fidx = 0;
 XFontStruct		*bar_fs;
 char			*bar_fonts[] = { NULL, NULL, NULL, NULL };/* XXX Make fully dynamic */
 char			*spawn_term[] = { NULL, NULL };		/* XXX Make fully dynamic */
+struct passwd		*pwd;
 
 #define SWM_MENU_FN	(2)
 #define SWM_MENU_NB	(4)
@@ -291,6 +329,15 @@ struct ws_win {
 };
 TAILQ_HEAD(ws_win_list, ws_win);
 
+/* pid goo */
+struct pid_e {
+	TAILQ_ENTRY(pid_e)	entry;
+	long			pid;
+	int			ws;
+};
+TAILQ_HEAD(pid_list, pid_e);
+struct pid_list			pidlist = TAILQ_HEAD_INITIALIZER(pidlist);
+
 /* layout handlers */
 void	stack(void);
 void	vertical_config(struct workspace *, int);
@@ -298,6 +345,8 @@ void	vertical_stack(struct workspace *, struct swm_geometry *);
 void	horizontal_config(struct workspace *, int);
 void	horizontal_stack(struct workspace *, struct swm_geometry *);
 void	max_stack(struct workspace *, struct swm_geometry *);
+void	plain_stacker(struct workspace *);
+void	fancy_stacker(struct workspace *);
 
 struct ws_win *find_window(Window);
 
@@ -306,24 +355,28 @@ void	new_region(struct swm_screen *, int, int, int, int);
 void	unmanage_window(struct ws_win *);
 long	getstate(Window);
 
+int	conf_load(char *, int);
+
 struct layout {
 	void		(*l_stack)(struct workspace *, struct swm_geometry *);
 	void		(*l_config)(struct workspace *, int);
 	u_int32_t	flags;
 #define SWM_L_FOCUSPREV		(1<<0)
 #define SWM_L_MAPONFOCUS	(1<<1)
-	char		*name;
+	void		(*l_string)(struct workspace *);
 } layouts[] =  {
 	/* stack,		configure */
-	{ vertical_stack,	vertical_config,	0,	"[|]" },
-	{ horizontal_stack,	horizontal_config,	0,	"[-]" },
+	{ vertical_stack,	vertical_config,	0,	plain_stacker },
+	{ horizontal_stack,	horizontal_config,	0,	plain_stacker },
 	{ max_stack,		NULL,
-	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			"[ ]"},
-	{ NULL,			NULL,			0,	NULL },
+	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			plain_stacker },
+	{ NULL,			NULL,			0,	NULL  },
 };
 
-/* position of max_stack mode in the layouts array */
-#define SWM_MAX_STACK		2
+/* position of max_stack mode in the layouts array, index into layouts! */
+#define SWM_V_STACK		(0)
+#define SWM_H_STACK		(1)
+#define SWM_MAX_STACK		(2)
 
 #define SWM_H_SLICE		(32)
 #define SWM_V_SLICE		(32)
@@ -331,6 +384,8 @@ struct layout {
 /* define work spaces */
 struct workspace {
 	int			idx;		/* workspace index */
+	char			*name;		/* workspace name */
+	int			always_raise;	/* raise windows on focus */
 	struct layout		*cur_layout;	/* current layout handlers */
 	struct ws_win		*focus;		/* may be NULL */
 	struct ws_win		*focus_prev;	/* may be NULL */
@@ -338,6 +393,7 @@ struct workspace {
 	struct swm_region	*old_r;		/* may be NULL */
 	struct ws_win_list	winlist;	/* list of windows in ws */
 	struct ws_win_list	unmanagedlist;	/* list of dead windows in ws */
+	char			stacker[10];	/* display stacker and layout */
 
 	/* stacker state */
 	struct {
@@ -392,6 +448,8 @@ union arg {
 #define SWM_ARG_ID_CYCLEWS_DOWN	(41)
 #define SWM_ARG_ID_CYCLESC_UP	(42)
 #define SWM_ARG_ID_CYCLESC_DOWN	(43)
+#define SWM_ARG_ID_CYCLEWS_UP_ALL	(44)
+#define SWM_ARG_ID_CYCLEWS_DOWN_ALL	(45)
 #define SWM_ARG_ID_STACKINC	(50)
 #define SWM_ARG_ID_STACKDEC	(51)
 #define SWM_ARG_ID_SS_ALL	(60)
@@ -400,6 +458,14 @@ union arg {
 #define SWM_ARG_ID_CENTER	(71)
 #define SWM_ARG_ID_KILLWINDOW	(80)
 #define SWM_ARG_ID_DELETEWINDOW	(81)
+#define SWM_ARG_ID_WIDTHGROW	(90)
+#define SWM_ARG_ID_WIDTHSHRINK	(91)
+#define SWM_ARG_ID_HEIGHTGROW	(92)
+#define SWM_ARG_ID_HEIGHTSHRINK	(93)
+#define SWM_ARG_ID_MOVEUP	(100)
+#define SWM_ARG_ID_MOVEDOWN	(101)
+#define SWM_ARG_ID_MOVELEFT	(102)
+#define SWM_ARG_ID_MOVERIGHT	(103)
 	char			**argv;
 };
 
@@ -556,7 +622,8 @@ setup_ewmh(void)
 		/* Report supported atoms */
 		XDeleteProperty(display, screens[i].root, sup_list);
 		for (j = 0; j < LENGTH(ewmh); j++)
-			XChangeProperty(display, screens[i].root, sup_list, XA_ATOM, 32,
+			XChangeProperty(display, screens[i].root,
+			    sup_list, XA_ATOM, 32,
 			    PropModeAppend, (unsigned char *)&ewmh[j].atom,1);
 	}
 }
@@ -593,12 +660,11 @@ void
 ewmh_autoquirk(struct ws_win *win)
 {
 	int			success, i;
-	unsigned long		*data = NULL;
-	unsigned long		n;
+	unsigned long		*data = NULL, n;
 	Atom			type;
 
 	success = get_property(win->id, ewmh[_NET_WM_WINDOW_TYPE].atom, (~0L),
-	    XA_ATOM, &n, (unsigned char **)&data);
+	    XA_ATOM, &n, (void *)&data);
 
 	if (!success) {
 		XFree(data);
@@ -742,7 +808,8 @@ ewmh_update_win_state(struct ws_win *win, long state, long action)
 			win->manual = (win->ewmh_flags & SWM_F_MANUAL) != 0;
 	if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom)
 		if (changed)
-			if (!ewmh_set_win_fullscreen(win, win->ewmh_flags & EWMH_F_FULLSCREEN))
+			if (!ewmh_set_win_fullscreen(win,
+			    win->ewmh_flags & EWMH_F_FULLSCREEN))
 				win->ewmh_flags = orig_flags; /* revert */
 
 	XDeleteProperty(display, win->id, ewmh[_NET_WM_STATE].atom);
@@ -785,8 +852,8 @@ ewmh_get_win_state(struct ws_win *win)
 	if (win->manual)
 		win->ewmh_flags |= SWM_F_MANUAL;
 
-	success = get_property(win->id, ewmh[_NET_WM_STATE].atom, (~0L), XA_ATOM,
-	    &n, (unsigned char **)&states);
+	success = get_property(win->id, ewmh[_NET_WM_STATE].atom,
+	    (~0L), XA_ATOM, &n, (void *)&states);
 
 	if (!success)
 		return;
@@ -1044,6 +1111,24 @@ sighdlr(int sig)
 	errno = saved_errno;
 }
 
+struct pid_e *
+find_pid(long pid)
+{
+	struct pid_e		*p = NULL;
+
+	DNPRINTF(SWM_D_MISC, "find_pid: %lu\n", pid);
+
+	if (pid == 0)
+		return (NULL);
+
+	TAILQ_FOREACH(p, &pidlist, entry) {
+		if (p->pid == pid)
+			return (p);
+	}
+
+	return (NULL);
+}
+
 unsigned long
 name_to_color(char *colorname)
 {
@@ -1076,40 +1161,63 @@ setscreencolor(char *val, int i, int c)
 		screens[i - 1].c[c].color = name_to_color(val);
 		free(screens[i - 1].c[c].name);
 		if ((screens[i - 1].c[c].name = strdup(val)) == NULL)
-			errx(1, "strdup");
+			err(1, "strdup");
 	} else if (i == -1) {
 		for (i = 0; i < ScreenCount(display); i++) {
 			screens[i].c[c].color = name_to_color(val);
 			free(screens[i].c[c].name);
 			if ((screens[i].c[c].name = strdup(val)) == NULL)
-				errx(1, "strdup");
+				err(1, "strdup");
 		}
 	} else
-		errx(1, "invalid screen index: %d out of bounds (maximum %d)\n",
+		errx(1, "invalid screen index: %d out of bounds (maximum %d)",
 		    i, ScreenCount(display));
 }
 
 void
+fancy_stacker(struct workspace *ws)
+{
+	strlcpy(ws->stacker, "[   ]", sizeof ws->stacker);
+	if (ws->cur_layout->l_stack == vertical_stack)
+		snprintf(ws->stacker, sizeof ws->stacker, "[%d|%d]",
+		    ws->l_state.vertical_mwin, ws->l_state.vertical_stacks);
+	if (ws->cur_layout->l_stack == horizontal_stack)
+		snprintf(ws->stacker, sizeof ws->stacker, "[%d-%d]",
+		    ws->l_state.horizontal_mwin, ws->l_state.horizontal_stacks);
+}
+
+void
+plain_stacker(struct workspace *ws)
+{
+	strlcpy(ws->stacker, "[ ]", sizeof ws->stacker);
+	if (ws->cur_layout->l_stack == vertical_stack)
+		strlcpy(ws->stacker, "[|]", sizeof ws->stacker);
+	if (ws->cur_layout->l_stack == horizontal_stack)
+		strlcpy(ws->stacker, "[-]", sizeof ws->stacker);
+}
+
+void
 custom_region(char *val)
 {
 	unsigned int			sidx, x, y, w, h;
 
 	if (sscanf(val, "screen[%u]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5)
 		errx(1, "invalid custom region, "
-		    "should be 'screen[<n>]:<n>x<n>+<n>+<n>\n");
+		    "should be 'screen[<n>]:<n>x<n>+<n>+<n>");
 	if (sidx < 1 || sidx > ScreenCount(display))
-		errx(1, "invalid screen index: %d out of bounds (maximum %d)\n",
+		errx(1, "invalid screen index: %d out of bounds (maximum %d)",
 		    sidx, ScreenCount(display));
 	sidx--;
 
 	if (w < 1 || h < 1)
-		errx(1, "region %ux%u+%u+%u too small\n", w, h, x, y);
+		errx(1, "region %ux%u+%u+%u too small", w, h, x, y);
 
-	if (x  < 0 || x > DisplayWidth(display, sidx) ||
-	    y < 0 || y > DisplayHeight(display, sidx) ||
+	if (x > DisplayWidth(display, sidx) ||
+	    y > DisplayHeight(display, sidx) ||
 	    w + x > DisplayWidth(display, sidx) ||
 	    h + y > DisplayHeight(display, sidx)) {
-		fprintf(stderr, "ignoring region %ux%u+%u+%u - not within screen boundaries "
+		fprintf(stderr, "ignoring region %ux%u+%u+%u "
+		    "- not within screen boundaries "
 		    "(%ux%u)\n", w, h, x, y,
 		    DisplayWidth(display, sidx), DisplayHeight(display, sidx));
 		return;
@@ -1133,10 +1241,31 @@ socket_setnonblock(int fd)
 void
 bar_print(struct swm_region *r, char *s)
 {
+	int			textwidth, x = 0;
+	size_t		len;
+
 	XClearWindow(display, r->bar_window);
 	XSetForeground(display, bar_gc, r->s->c[SWM_S_COLOR_BAR_FONT].color);
-	XDrawString(display, r->bar_window, bar_gc, 4, bar_fs->ascent, s,
-	    strlen(s));
+
+	len = strlen(s);
+	textwidth = XTextWidth(bar_fs, s, len);
+
+	switch (bar_justify) {
+	case SWM_BAR_JUSTIFY_LEFT:
+		x = SWM_BAR_OFFSET;
+		break;
+	case SWM_BAR_JUSTIFY_CENTER:
+		x = (WIDTH(r) - textwidth) / 2;
+		break;
+	case SWM_BAR_JUSTIFY_RIGHT:
+		x = WIDTH(r) - textwidth - SWM_BAR_OFFSET;
+		break;
+	}
+
+	if (x < SWM_BAR_OFFSET)
+		x = SWM_BAR_OFFSET;
+
+	XDrawString(display, r->bar_window, bar_gc, x, bar_fs->ascent, s, len);
 }
 
 void
@@ -1200,6 +1329,44 @@ bar_window_name(char *s, ssize_t sz, struct ws_win *cur_focus)
 	}
 }
 
+int		urgent[SWM_WS_MAX];
+void
+bar_urgent(char *s, ssize_t sz)
+{
+	XWMHints		*wmh = NULL;
+	struct ws_win		*win;
+	int			i, j;
+	char			b[8];
+
+	if (urgent_enabled == 0)
+		return;
+
+	for (i = 0; i < SWM_WS_MAX; i++)
+		urgent[i] = 0;
+
+	for (i = 0; i < ScreenCount(display); i++)
+		for (j = 0; j < SWM_WS_MAX; j++)
+			TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry) {
+				wmh = XGetWMHints(display, win->id);
+				if (wmh == NULL)
+					continue;
+
+				if (wmh->flags & XUrgencyHint)
+					urgent[j] = 1;
+				XFree(wmh);
+			}
+
+	strlcat(s, "* ", sz);
+	for (i = 0; i < SWM_WS_MAX; i++) {
+		if (urgent[i])
+			snprintf(b, sizeof b, "%d ", i + 1);
+		else
+			snprintf(b, sizeof b, "- ");
+		strlcat(s, b, sz);
+	}
+	strlcat(s, "*    ", sz);
+}
+
 void
 bar_update(void)
 {
@@ -1208,11 +1375,11 @@ bar_update(void)
 	struct swm_region	*r;
 	int			i, x;
 	size_t			len;
+	char			ws[SWM_BAR_MAX];
 	char			s[SWM_BAR_MAX];
 	char			cn[SWM_BAR_MAX];
 	char			loc[SWM_BAR_MAX];
-	char			*b;
-	char			*stack = "";
+	char			*b, *stack = "";
 
 	if (bar_enabled == 0)
 		return;
@@ -1244,16 +1411,19 @@ bar_update(void)
 		x = 1;
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {
 			strlcpy(cn, "", sizeof cn);
+			strlcpy(ws, "", sizeof ws);
 			if (r && r->ws) {
+				bar_urgent(cn, sizeof cn);
 				bar_class_name(cn, sizeof cn, r->ws->focus);
 				bar_window_name(cn, sizeof cn, r->ws->focus);
+				if (r->ws->name)
+					snprintf(ws, sizeof ws, "<%s>", r->ws->name);
 			}
-
 			if (stack_enabled)
-				stack = r->ws->cur_layout->name;
+				stack = r->ws->stacker;
 
-			snprintf(loc, sizeof loc, "%d:%d %s   %s%s    %s    %s",
-			    x++, r->ws->idx + 1, stack, s, cn, bar_ext,
+			snprintf(loc, sizeof loc, "%d:%d %s %s   %s%s    %s    %s",
+			    x++, r->ws->idx + 1, stack, ws, s, cn, bar_ext,
 			    bar_vertext);
 			bar_print(r, loc);
 		}
@@ -1307,9 +1477,9 @@ bar_refresh(void)
 		socket_setnonblock(bar_pipe[0]);
 		socket_setnonblock(bar_pipe[1]); /* XXX hmmm, really? */
 		if (dup2(bar_pipe[0], 0) == -1)
-			errx(1, "dup2");
+			err(1, "dup2");
 		if (dup2(bar_pipe[1], 1) == -1)
-			errx(1, "dup2");
+			err(1, "dup2");
 		if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
 			err(1, "could not disable SIGPIPE");
 		switch (bar_pid = fork()) {
@@ -1358,16 +1528,18 @@ bar_setup(struct swm_region *r)
 		}
 	}
 	if (bar_fonts[i] == NULL)
-			errx(1, "couldn't load font");
+		errx(1, "couldn't load font");
 	if (bar_fs == NULL)
 		errx(1, "couldn't create font structure");
 
-	bar_height = bar_fs->ascent + bar_fs->descent + 1 + 2 * bar_border_width;
+	bar_height = bar_fs->ascent + bar_fs->descent + 1 +
+	    2 * bar_border_width;
 	x = X(r);
 	y = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r);
 
 	r->bar_window = XCreateSimpleWindow(display,
-	    r->s->root, x, y, WIDTH(r) - 2 * bar_border_width, bar_height - 2 * bar_border_width,
+	    r->s->root, x, y, WIDTH(r) - 2 * bar_border_width,
+	    bar_height - 2 * bar_border_width,
 	    bar_border_width, r->s->c[SWM_S_COLOR_BAR_BORDER].color,
 	    r->s->c[SWM_S_COLOR_BAR].color);
 	bar_gc = XCreateGC(display, r->bar_window, 0, &bar_gcv);
@@ -1428,8 +1600,8 @@ version(struct swm_region *r, union arg *args)
 {
 	bar_version = !bar_version;
 	if (bar_version)
-		snprintf(bar_vertext, sizeof bar_vertext, "Version: %s CVS: %s",
-		    SWM_VERSION, cvstag);
+		snprintf(bar_vertext, sizeof bar_vertext, "Version: %s Build: %s",
+		    SCROTWM_VERSION, buildstr);
 	else
 		strlcpy(bar_vertext, "", sizeof bar_vertext);
 	bar_update();
@@ -1462,7 +1634,8 @@ config_win(struct ws_win *win, XConfigureRequestEvent  *ev)
 		return;
 
 	if (ev == NULL) {
-		DNPRINTF(SWM_D_MISC, "config_win: win %lu x %d y %d w %d h %d\n",
+		DNPRINTF(SWM_D_MISC,
+		    "config_win: win %lu x %d y %d w %d h %d\n",
 		    win->id, win->g.x, win->g.y, win->g.w, win->g.h);
 
 		ce.type = ConfigureNotify;
@@ -1477,7 +1650,8 @@ config_win(struct ws_win *win, XConfigureRequestEvent  *ev)
 		ce.above = None;
 		ce.override_redirect = False;
 	} else {
-		DNPRINTF(SWM_D_MISC, "config_win: ev win %lu x %d y %d w %d h %d\n",
+		DNPRINTF(SWM_D_MISC,
+		    "config_win: ev win %lu x %d y %d w %d h %d\n",
 		    ev->window, ev->x, ev->y, ev->width, ev->height);
 		ce.type = ConfigureNotify;
 		ce.display = ev->display;
@@ -1590,7 +1764,7 @@ restart(struct swm_region *r, union arg *args)
 	/* disable alarm because the following code may not be interrupted */
 	alarm(0);
 	if (signal(SIGALRM, SIG_IGN) == SIG_ERR)
-		errx(1, "can't disable alarm");
+		err(1, "can't disable alarm");
 
 	bar_extra_stop();
 	bar_extra = 1;
@@ -1679,7 +1853,7 @@ find_window(Window id)
 }
 
 void
-spawn(struct swm_region *r, union arg *args, int close_fd)
+spawn(int ws_idx, union arg *args, int close_fd)
 {
 	int			fd;
 	char			*ret = NULL;
@@ -1691,7 +1865,7 @@ spawn(struct swm_region *r, union arg *args, int close_fd)
 
 	setenv("LD_PRELOAD", SWM_LIB, 1);
 
-	if (asprintf(&ret, "%d", r->ws->idx) == -1) {
+	if (asprintf(&ret, "%d", ws_idx) == -1) {
 		perror("_SWM_WS");
 		_exit(1);
 	}
@@ -1739,10 +1913,11 @@ spawnterm(struct swm_region *r, union arg *args)
 {
 	DNPRINTF(SWM_D_MISC, "spawnterm\n");
 
-	if (term_width)
-		setenv("_SWM_XTERM_FONTADJ", "", 1);
-	if (fork() == 0)
-		spawn(r, args, 1);
+	if (fork() == 0) {
+		if (term_width)
+			setenv("_SWM_XTERM_FONTADJ", "", 1);
+		spawn(r->ws->idx, args, 1);
+	}
 }
 
 void
@@ -1772,12 +1947,12 @@ validate_win(struct ws_win *testwin)
 	struct ws_win		*win;
 	struct workspace	*ws;
 	struct swm_region	*r;
-	int			i, x, foundit = 0;
+	int			i, x;
 
 	if (testwin == NULL)
-		return(0);
+		return (0);
 
-	for (i = 0, foundit = 0; i < ScreenCount(display); i++)
+	for (i = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
 			for (x = 0; x < SWM_WS_MAX; x++) {
 				ws = &r->s->ws[x];
@@ -1793,10 +1968,10 @@ validate_ws(struct workspace *testws)
 {
 	struct swm_region	*r;
 	struct workspace	*ws;
-	int			foundit, i, x;
+	int			i, x;
 
 	/* validate all ws */
-	for (i = 0, foundit = 0; i < ScreenCount(display); i++)
+	for (i = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
 			for (x = 0; x < SWM_WS_MAX; x++) {
 				ws = &r->s->ws[x];
@@ -1906,8 +2081,9 @@ focus_win(struct ws_win *win)
 	else {
 		/* use larger hammer since the window was killed somehow */
 		TAILQ_FOREACH(cfw, &win->ws->winlist, entry)
-			XSetWindowBorder(display, cfw->id,
-			    cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+			if (cfw->ws && cfw->ws->r && cfw->ws->r->s)
+				XSetWindowBorder(display, cfw->id,
+				    cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
 	}
 
 	win->ws->focus = win;
@@ -1920,11 +2096,11 @@ focus_win(struct ws_win *win)
 		if (win->java == 0)
 			XSetInputFocus(display, win->id,
 			    RevertToParent, CurrentTime);
-		XMapRaised(display, win->id);
 		grabbuttons(win, 1);
 		XSetWindowBorder(display, win->id,
 		    win->ws->r->s->c[SWM_S_COLOR_FOCUS].color);
-		if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS)
+		if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS ||
+		    win->ws->always_raise)
 			XMapRaised(display, win->id);
 
 		XChangeProperty(display, win->s->root,
@@ -1999,6 +2175,7 @@ cyclews(struct swm_region *r, union arg *args)
 {
 	union			arg a;
 	struct swm_screen	*s = r->s;
+	int			cycle_all = 0;
 
 	DNPRINTF(SWM_D_WS, "cyclews id %d "
 	    "in screen[%d]:%dx%d+%d+%d ws %d\n", args->id,
@@ -2007,12 +2184,18 @@ cyclews(struct swm_region *r, union arg *args)
 	a.id = r->ws->idx;
 	do {
 		switch (args->id) {
+		case SWM_ARG_ID_CYCLEWS_UP_ALL:
+			cycle_all = 1;
+			/* FALLTHROUGH */
 		case SWM_ARG_ID_CYCLEWS_UP:
 			if (a.id < SWM_WS_MAX - 1)
 				a.id++;
 			else
 				a.id = 0;
 			break;
+		case SWM_ARG_ID_CYCLEWS_DOWN_ALL:
+			cycle_all = 1;
+			/* FALLTHROUGH */
 		case SWM_ARG_ID_CYCLEWS_DOWN:
 			if (a.id > 0)
 				a.id--;
@@ -2023,7 +2206,8 @@ cyclews(struct swm_region *r, union arg *args)
 			return;
 		};
 
-		if (cycle_empty == 0 && TAILQ_EMPTY(&s->ws[a.id].winlist))
+		if (!cycle_all &&
+		    (cycle_empty == 0 && TAILQ_EMPTY(&s->ws[a.id].winlist)))
 			continue;
 		if (cycle_visible == 0 && s->ws[a.id].r != NULL)
 			continue;
@@ -2168,7 +2352,7 @@ swapwin(struct swm_region *r, union arg *args)
 				source = source->ws->focus_prev;
 			else
 				return;
-                }
+		}
 		if (target == NULL || source == NULL)
 			return;
 		source->ws->focus_prev = target;
@@ -2246,8 +2430,14 @@ focus_prev(struct ws_win *win)
 	if (winfocus == NULL || winfocus == win)
 		winfocus = TAILQ_NEXT(cur_focus, entry);
 done:
-	if (winfocus == winlostfocus || winfocus == NULL)
+	if (winfocus == winlostfocus || winfocus == NULL) {
+		/* update the bar so that title/class/name will be cleared. */
+		if (window_name_enabled || title_name_enabled ||
+		    title_class_enabled)
+			bar_update();
+		
 		return;
+	}
 
 	focus_magic(winfocus);
 }
@@ -2259,6 +2449,7 @@ focus(struct swm_region *r, union arg *args)
 	struct ws_win		*cur_focus = NULL;
 	struct ws_win_list	*wl = NULL;
 	struct workspace	*ws = NULL;
+	int			all_iconics;
 
 	if (!(r && r->ws))
 		return;
@@ -2284,6 +2475,17 @@ focus(struct swm_region *r, union arg *args)
 		return;
 	ws = r->ws;
 	wl = &ws->winlist;
+	if (TAILQ_EMPTY(wl))
+		return;
+	/* make sure there is at least one uniconified window */
+	all_iconics = 1;
+	TAILQ_FOREACH(winfocus, wl, entry)
+		if (winfocus->iconic == 0) {
+			all_iconics = 0;
+			break;
+		}
+	if (all_iconics)
+		return;
 
 	winlostfocus = cur_focus;
 
@@ -2302,9 +2504,13 @@ focus(struct swm_region *r, union arg *args)
 
 		/* skip iconics */
 		if (winfocus && winfocus->iconic) {
-			TAILQ_FOREACH_REVERSE(winfocus, wl, ws_win_list, entry)
+			while (winfocus != cur_focus) {
+				if (winfocus == NULL)
+					winfocus = TAILQ_LAST(wl, ws_win_list);
 				if (winfocus->iconic == 0)
 					break;
+				winfocus = TAILQ_PREV(winfocus, ws_win_list, entry);
+			}
 		}
 		break;
 
@@ -2316,9 +2522,13 @@ focus(struct swm_region *r, union arg *args)
 
 		/* skip iconics */
 		if (winfocus && winfocus->iconic) {
-			TAILQ_FOREACH(winfocus, wl, entry)
+			while (winfocus != cur_focus) {
+				if (winfocus == NULL)
+					winfocus = TAILQ_FIRST(wl);
 				if (winfocus->iconic == 0)
 					break;
+				winfocus = TAILQ_NEXT(winfocus, entry);
+			}
 		}
 		break;
 
@@ -2331,8 +2541,14 @@ focus(struct swm_region *r, union arg *args)
 	default:
 		return;
 	}
-	if (winfocus == winlostfocus || winfocus == NULL)
+	if (winfocus == winlostfocus || winfocus == NULL) {
+		/* update the bar so that title/class/name will be cleared. */
+		if (window_name_enabled || title_name_enabled ||
+		    title_class_enabled)
+			bar_update();
+
 		return;
+	}
 
 	focus_magic(winfocus);
 }
@@ -2341,13 +2557,10 @@ void
 cycle_layout(struct swm_region *r, union arg *args)
 {
 	struct workspace	*ws = r->ws;
-	struct ws_win		*winfocus;
 	union arg		a;
 
 	DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx);
 
-	winfocus = ws->focus;
-
 	ws->cur_layout++;
 	if (ws->cur_layout->l_stack == NULL)
 		ws->cur_layout = &layouts[0];
@@ -2371,20 +2584,26 @@ stack_config(struct swm_region *r, union arg *args)
 	if (ws->cur_layout->l_config != NULL)
 		ws->cur_layout->l_config(ws, args->id);
 
-	if (args->id != SWM_ARG_ID_STACKINIT);
+	if (args->id != SWM_ARG_ID_STACKINIT)
 		stack();
+	bar_update();
 }
 
 void
 stack(void) {
 	struct swm_geometry	g;
 	struct swm_region	*r;
-	int			i, j;
+	int			i;
+#ifdef SWM_DEBUG
+	int j;
+#endif
 
 	DNPRINTF(SWM_D_STACK, "stack\n");
 
 	for (i = 0; i < ScreenCount(display); i++) {
+#ifdef SWM_DEBUG
 		j = 0;
+#endif
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {
 			DNPRINTF(SWM_D_STACK, "stacking workspace %d "
 			    "(screen %d, region %d)\n", r->ws->idx, i, j++);
@@ -2399,6 +2618,7 @@ stack(void) {
 				g.h -= bar_height;
 			}
 			r->ws->cur_layout->l_stack(r->ws, &g);
+			r->ws->cur_layout->l_string(r->ws);
 			/* save r so we can track region changes */
 			r->ws->old_r = r;
 		}
@@ -2472,8 +2692,10 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 		 * floaters and transients are auto-centred unless moved
 		 * or resized
 		 */
-		win->g.x = r->g.x + (WIDTH(r) - win->g.w) / 2 - wc.border_width;
-		win->g.y = r->g.y + (HEIGHT(r) - win->g.h) / 2 - wc.border_width;
+		win->g.x = r->g.x + (WIDTH(r) - win->g.w) /
+		    2 - wc.border_width;
+		win->g.y = r->g.y + (HEIGHT(r) - win->g.h) /
+		    2 - wc.border_width;
 	}
 
 	/* win can be outside r if new r smaller than old r */
@@ -2563,7 +2785,8 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 		return;
 
 	TAILQ_FOREACH(win, &ws->winlist, entry)
-		if (win->transient == 0 && win->floating == 0 && win->iconic == 0)
+		if (win->transient == 0 && win->floating == 0
+		    && win->iconic == 0)
 			break;
 
 	if (win == NULL)
@@ -2612,7 +2835,8 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 	} else {
 		msize = -2;
 		colno = split = winno / stacks;
-		win_g.w = ((r_g.w - (stacks * 2 * border_width) + 2 * border_width) / stacks);
+		win_g.w = ((r_g.w - (stacks * 2 * border_width) +
+		    2 * border_width) / stacks);
 	}
 	hrh = r_g.h / colno;
 	extra = r_g.h - (colno * hrh);
@@ -2642,10 +2866,11 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 				win_g.x = r_g.x;
 			else
 				win_g.x += win_g.w + 2 * border_width;
-			win_g.w = (r_g.w - msize - (stacks * 2 * border_width)) / stacks;
+			win_g.w = (r_g.w - msize -
+			    (stacks * 2 * border_width)) / stacks;
 			if (s == 1)
-				win_g.w += (r_g.w - msize - (stacks * 2 * border_width)) %
-				    stacks;
+				win_g.w += (r_g.w - msize -
+				    (stacks * 2 * border_width)) % stacks;
 			s--;
 			j = 0;
 		}
@@ -2914,7 +3139,7 @@ send_to_ws(struct swm_region *r, union arg *args)
 	unsigned char		ws_idx_str[SWM_PROPLEN];
 	union arg		a;
 
-	if (r && r->ws)
+	if (r && r->ws && r->ws->focus)
 		win = r->ws->focus;
 	else
 		return;
@@ -2942,12 +3167,15 @@ send_to_ws(struct swm_region *r, union arg *args)
 	unmap_window(win);
 	TAILQ_REMOVE(&ws->winlist, win, entry);
 	TAILQ_INSERT_TAIL(&nws->winlist, win, entry);
+	if (TAILQ_EMPTY(&ws->winlist))
+		r->ws->focus = NULL;
 	win->ws = nws;
 
 	/* Try to update the window's workspace property */
 	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
 	if (ws_idx_atom &&
-	    snprintf(ws_idx_str, SWM_PROPLEN, "%d", nws->idx) < SWM_PROPLEN) {
+	    snprintf((char *)ws_idx_str, SWM_PROPLEN, "%d", nws->idx) <
+	        SWM_PROPLEN) {
 		DNPRINTF(SWM_D_PROP, "setting property _SWM_WS to %s\n",
 		    ws_idx_str);
 		XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
@@ -2958,6 +3186,26 @@ send_to_ws(struct swm_region *r, union arg *args)
 }
 
 void
+pressbutton(struct swm_region *r, union arg *args)
+{
+	XTestFakeButtonEvent(display, args->id, True, CurrentTime);
+	XTestFakeButtonEvent(display, args->id, False, CurrentTime);
+}
+
+void
+raise_toggle(struct swm_region *r, union arg *args)
+{
+	if (r && r->ws == NULL)
+		return;
+
+	r->ws->always_raise = !r->ws->always_raise;
+
+	/* bring floaters back to top */
+	if (r->ws->always_raise == 0)
+		stack();
+}
+
+void
 iconify(struct swm_region *r, union arg *args)
 {
 	union arg a;
@@ -3008,7 +3256,7 @@ uniconify(struct swm_region *r, union arg *args)
 {
 	struct ws_win		*win;
 	FILE			*lfile;
-	char			*name;
+	unsigned char		*name;
 	int			count = 0;
 	unsigned long		len;
 
@@ -3029,8 +3277,9 @@ uniconify(struct swm_region *r, union arg *args)
 		return;
 
 	search_r = r;
+	search_resp_action = SWM_SEARCH_UNICONIFY;
 
-	spawn_select(r, args, "uniconify", &searchpid);
+	spawn_select(r, args, "search", &searchpid);
 
 	if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL)
 		return;
@@ -3041,7 +3290,7 @@ uniconify(struct swm_region *r, union arg *args)
 		if (win->iconic == 0)
 			continue;
 
-		name = get_win_name(display, win->id, a_wmname, a_string,
+		name = get_win_name(display, win->id, a_netwmname, a_utf8_string,
 		    &len);
 		if (name == NULL)
 			continue;
@@ -3052,39 +3301,152 @@ uniconify(struct swm_region *r, union arg *args)
 	fclose(lfile);
 }
 
-#define MAX_RESP_LEN	1024
+void
+name_workspace(struct swm_region *r, union arg *args)
+{
+	FILE			*lfile;
+
+	DNPRINTF(SWM_D_MISC, "name_workspace\n");
+
+	if (r == NULL)
+		return;
+
+	search_r = r;
+	search_resp_action = SWM_SEARCH_NAME_WORKSPACE;
+
+	spawn_select(r, args, "name_workspace", &searchpid);
+
+	if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL)
+		return;
+
+	fprintf(lfile, "%s", "");
+	fclose(lfile);
+}
 
 void
-search_do_resp(void)
+search_workspace(struct swm_region *r, union arg *args)
 {
-	ssize_t			rbytes;
-	struct ws_win		*win;
-	char			*name, *resp, *s;
-	unsigned long		len;
+	int			i;
+	struct workspace	*ws;
+	FILE			*lfile;
 
-	DNPRINTF(SWM_D_MISC, "search_do_resp:\n");
+	DNPRINTF(SWM_D_MISC, "search_workspace\n");
 
-	search_resp = 0;
-	searchpid = 0;
+	if (r == NULL)
+		return;
 
-	if ((resp = calloc(1, MAX_RESP_LEN + 1)) == NULL) {
-		fprintf(stderr, "search: calloc\n");
+	search_r = r;
+	search_resp_action = SWM_SEARCH_SEARCH_WORKSPACE;
+
+	spawn_select(r, args, "search", &searchpid);
+
+	if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL)
 		return;
+
+	for (i = 0; i < SWM_WS_MAX; i++) {
+		ws = &r->s->ws[i];
+		if (ws == NULL)
+			continue;
+		fprintf(lfile, "%d%s%s\n", ws->idx + 1,
+		    (ws->name ? ":" : ""), (ws->name ? ws->name : ""));
 	}
 
-	rbytes = read(select_resp_pipe[0], resp, MAX_RESP_LEN);
-	if (rbytes <= 0) {
-		fprintf(stderr, "search: read error: %s\n", strerror(errno));
-		goto done;
+	fclose(lfile);
+}
+
+void
+search_win_cleanup(void)
+{
+	struct search_window	*sw = NULL;
+
+	while ((sw = TAILQ_FIRST(&search_wl)) != NULL) {
+		XDestroyWindow(display, sw->indicator);
+		TAILQ_REMOVE(&search_wl, sw, entry);
+		free(sw);
 	}
-	resp[rbytes] = '\0';
-	len = strlen(resp);
+}
+
+void
+search_win(struct swm_region *r, union arg *args)
+{
+	struct ws_win		*win = NULL;
+	struct search_window	*sw = NULL;
+	Window			w;
+	GC			gc;
+	XGCValues		gcv;
+	int			i;
+	char			s[8];
+	FILE			*lfile;
+	size_t			len;
+	int			textwidth;
+
+	DNPRINTF(SWM_D_MISC, "search_win\n");
+
+	search_r = r;
+	search_resp_action = SWM_SEARCH_SEARCH_WINDOW;
+
+	spawn_select(r, args, "search", &searchpid);
+
+	if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL)
+		return;
+
+	TAILQ_INIT(&search_wl);
+
+	i = 1;
+	TAILQ_FOREACH(win, &r->ws->winlist, entry) {
+		if (win->iconic == 1)
+			continue;
+
+		sw = calloc(1, sizeof(struct search_window));
+		if (sw == NULL) {
+			fprintf(stderr, "search_win: calloc: %s", strerror(errno));
+			fclose(lfile);
+			search_win_cleanup();
+			return;
+		}
+		sw->idx = i;
+		sw->win = win;
+
+		snprintf(s, sizeof s, "%d", i);
+		len = strlen(s);
+		textwidth = XTextWidth(bar_fs, s, len);
+
+		w = XCreateSimpleWindow(display,
+		    win->id, 0, 0, textwidth + 12,
+		    bar_fs->ascent + bar_fs->descent + 4, 1,
+		    r->s->c[SWM_S_COLOR_UNFOCUS].color,
+		    r->s->c[SWM_S_COLOR_FOCUS].color);
+
+		sw->indicator = w;
+		TAILQ_INSERT_TAIL(&search_wl, sw, entry);
+
+		gc = XCreateGC(display, w, 0, &gcv);
+		XSetFont(display, gc, bar_fs->fid);
+		XMapRaised(display, w);
+		XSetForeground(display, gc, r->s->c[SWM_S_COLOR_BAR].color);
+
+		XDrawString(display, w, gc, 6, bar_fs->ascent + 2, s, len);
+
+		fprintf(lfile, "%d\n", i);
+		i++;
+	}
+
+	fclose(lfile);
+}
+
+void
+search_resp_uniconify(char *resp, unsigned long len)
+{
+	unsigned char		*name;
+	struct ws_win		*win;
+	char			*s;
+
+	DNPRINTF(SWM_D_MISC, "search_resp_uniconify: resp %s\n", resp);
 
-	DNPRINTF(SWM_D_MISC, "search_do_resp: resp %s\n", resp);
 	TAILQ_FOREACH(win, &search_r->ws->winlist, entry) {
 		if (win->iconic == 0)
 			continue;
-		name = get_win_name(display, win->id, a_wmname, a_string, &len);
+		name = get_win_name(display, win->id, a_netwmname, a_utf8_string, &len);
 		if (name == NULL)
 			continue;
 		if (asprintf(&s, "%s.%lu", name, win->id) == -1) {
@@ -3100,7 +3462,152 @@ search_do_resp(void)
 		}
 		free(s);
 	}
+}
+
+void
+search_resp_name_workspace(char *resp, unsigned long len)
+{
+	struct workspace	*ws;
+
+	DNPRINTF(SWM_D_MISC, "search_resp_name_workspace: resp %s\n", resp);
+
+	if (search_r->ws == NULL)
+		return;
+	ws = search_r->ws;
+
+	if (ws->name) {
+		free(search_r->ws->name);
+		search_r->ws->name = NULL;
+	}
+
+	if (len > 1) {
+		ws->name = strdup(resp);
+		if (ws->name == NULL) {
+			DNPRINTF(SWM_D_MISC, "search_resp_name_workspace: strdup: %s",
+			    strerror(errno));
+			return;
+		}
+	}
+}
+
+void
+search_resp_search_workspace(char *resp, unsigned long len)
+{
+	char			*p, *q;
+	int			ws_idx;
+	const char		*errstr;
+	union arg		a;
+
+	DNPRINTF(SWM_D_MISC, "search_resp_search_workspace: resp %s\n", resp);
+
+	q = strdup(resp);
+	if (!q) {
+		DNPRINTF(SWM_D_MISC, "search_resp_search_workspace: strdup: %s",
+		    strerror(errno));
+		return;
+	}
+	p = strchr(q, ':');
+	if (p != NULL)
+		*p = '\0';
+	ws_idx = strtonum(q, 1, SWM_WS_MAX, &errstr);
+	if (errstr) {
+		DNPRINTF(SWM_D_MISC, "workspace idx is %s: %s",
+		    errstr, q);
+		free(q);
+		return;
+	}
+	free(q);
+	a.id = ws_idx - 1;
+	switchws(search_r, &a);
+}
+
+void
+search_resp_search_window(char *resp, unsigned long len)
+{
+	char			*s;
+	int			idx;
+	const char		*errstr;
+	struct search_window	*sw;
+
+	DNPRINTF(SWM_D_MISC, "search_resp_search_window: resp %s\n", resp);
+
+	s = strdup(resp);
+	if (!s) {
+		DNPRINTF(SWM_D_MISC, "search_resp_search_window: strdup: %s",
+		    strerror(errno));
+		return;
+	}
+
+	idx = strtonum(s, 1, INT_MAX, &errstr);
+	if (errstr) {
+		DNPRINTF(SWM_D_MISC, "window idx is %s: %s",
+		    errstr, s);
+		free(s);
+		return;
+	}
+	free(s);
+
+	TAILQ_FOREACH(sw, &search_wl, entry)
+		if (idx == sw->idx) {
+			focus_win(sw->win);
+			break;
+		}
+}
+
+#define MAX_RESP_LEN	1024
+
+void
+search_do_resp(void)
+{
+	ssize_t			rbytes;
+	char			*resp;
+	unsigned long		len;
+
+	DNPRINTF(SWM_D_MISC, "search_do_resp:\n");
+
+	search_resp = 0;
+	searchpid = 0;
+
+	if ((resp = calloc(1, MAX_RESP_LEN + 1)) == NULL) {
+		fprintf(stderr, "search: calloc\n");
+		goto done;
+	}
+
+	rbytes = read(select_resp_pipe[0], resp, MAX_RESP_LEN);
+	if (rbytes <= 0) {
+		fprintf(stderr, "search: read error: %s\n", strerror(errno));
+		goto done;
+	}
+	resp[rbytes] = '\0';
+
+	/* XXX:
+	 * Older versions of dmenu (Atleast pre 4.4.1) do not send a
+	 * newline, so work around that by sanitizing the resp now.
+	 */
+	resp[strcspn(resp, "\n")] = '\0';
+	len = strlen(resp);
+
+	switch (search_resp_action) {
+	case SWM_SEARCH_UNICONIFY:
+		search_resp_uniconify(resp, len);
+		break;
+	case SWM_SEARCH_NAME_WORKSPACE:
+		search_resp_name_workspace(resp, len);
+		break;
+	case SWM_SEARCH_SEARCH_WORKSPACE:
+		search_resp_search_workspace(resp, len);
+		break;
+	case SWM_SEARCH_SEARCH_WINDOW:
+		search_resp_search_window(resp, len);
+		break;
+	}
+
 done:
+	if (search_resp_action == SWM_SEARCH_SEARCH_WINDOW)
+		search_win_cleanup();
+
+	search_resp_action = SWM_SEARCH_NONE;
+	close(select_resp_pipe[0]);
 	free(resp);
 }
 
@@ -3182,38 +3689,83 @@ floating_toggle(struct swm_region *r, union arg *args)
 }
 
 void
-resize_window(struct ws_win *win, int center)
+constrain_window(struct ws_win *win, struct swm_region *r, int resizable)
+{
+	if (win->g.x + win->g.w > r->g.x + r->g.w - border_width) {
+		if (resizable) 
+			win->g.w = r->g.x + r->g.w - win->g.x - border_width;
+		else
+			win->g.x = r->g.x + r->g.w - win->g.w - border_width;
+	}
+	
+	if (win->g.x < r->g.x - border_width) {
+		if (resizable)
+			win->g.w -= r->g.x - win->g.x - border_width;
+
+		win->g.x = r->g.x - border_width;
+	}
+
+	if (win->g.y + win->g.h > r->g.y + r->g.h - border_width) {
+		if (resizable)
+			win->g.h = r->g.y + r->g.h - win->g.y - border_width;
+		else
+			win->g.y = r->g.y + r->g.h - win->g.h - border_width;
+	}
+	
+	if (win->g.y < r->g.y - border_width) {
+		if (resizable)
+			win->g.h -= r->g.y - win->g.y - border_width;
+
+		win->g.y = r->g.y - border_width;
+	}
+
+	if (win->g.w < 1)
+		win->g.w = 1;
+	if (win->g.h < 1)
+		win->g.h = 1;
+}
+
+void
+update_window(struct ws_win *win)
 {
 	unsigned int		mask;
 	XWindowChanges		wc;
-	struct swm_region	*r;
 
-	r = root_to_region(win->wa.root);
 	bzero(&wc, sizeof wc);
-	mask = CWBorderWidth | CWWidth | CWHeight;
+	mask = CWBorderWidth | CWWidth | CWHeight | CWX | CWY;
 	wc.border_width = border_width;
+	wc.x = win->g.x;
+	wc.y = win->g.y;
 	wc.width = win->g.w;
 	wc.height = win->g.h;
-	if (center == SWM_ARG_ID_CENTER) {
-		wc.x = (WIDTH(r) - win->g.w) / 2 - border_width;
-		wc.y = (HEIGHT(r) - win->g.h) / 2 - border_width;
-		mask |= CWX | CWY;
-	}
 
-	DNPRINTF(SWM_D_STACK, "resize_window: win %lu x %d y %d w %d h %d\n",
+	DNPRINTF(SWM_D_STACK, "update_window: win %lu x %d y %d w %d h %d\n",
 	    win->id, wc.x, wc.y, wc.width, wc.height);
 
 	XConfigureWindow(display, win->id, mask, &wc);
 }
 
+#define SWM_RESIZE_STEPS	(50)
+
 void
 resize(struct ws_win *win, union arg *args)
 {
 	XEvent			ev;
 	Time			time = 0;
-	struct swm_region	*r = win->ws->r;
-	int			relx, rely;
+	struct swm_region	*r = NULL;
+	int			resize_step = 0;
+	Window			rr, cr;
+	int			x, y, wx, wy;
+	unsigned int		mask;
+	struct swm_geometry	g;
+	int			top = 0, left = 0;
+	int 			dx, dy;
+	Cursor			cursor;
+	unsigned int		shape; /* cursor style */
 
+	if (win == NULL)
+		return;
+	r = win->ws->r;
 
 	DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
@@ -3230,98 +3782,172 @@ resize(struct ws_win *win, union arg *args)
 	    _NET_WM_STATE_ADD);
 
 	stack();
+
+	switch (args->id) {
+	case SWM_ARG_ID_WIDTHSHRINK:
+		win->g.w -= SWM_RESIZE_STEPS;
+		resize_step = 1;
+		break;
+	case SWM_ARG_ID_WIDTHGROW:
+		win->g.w += SWM_RESIZE_STEPS;
+		resize_step = 1;
+		break;
+	case SWM_ARG_ID_HEIGHTSHRINK:
+		win->g.h -= SWM_RESIZE_STEPS;
+		resize_step = 1;
+		break;
+	case SWM_ARG_ID_HEIGHTGROW:
+		win->g.h += SWM_RESIZE_STEPS;
+		resize_step = 1;
+		break;
+	default:
+		break;
+	}
+	if (resize_step) {
+		constrain_window(win, r, 1);
+		update_window(win);
+		store_float_geom(win,r);
+		return;
+	}
+
 	if (focus_mode == SWM_FOCUS_DEFAULT)
 		drain_enter_notify();
 
-	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
-	    GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
-		return;
+	/* get cursor offset from window root */
+	if (!XQueryPointer(display, win->id, &rr, &cr, &x, &y, &wx, &wy, &mask))
+	    return;
 
-	/* place pointer at bottom left corner or nearest point inside r */
-	if ( win->g.x + win->g.w < r->g.x + r->g.w - 1)
-		relx = win->g.w - 1;
-	else
-		relx = r->g.x + r->g.w - win->g.x - 1;
+	g = win->g;
 
-	if ( win->g.y + win->g.h < r->g.y + r->g.h - 1)
-		rely = win->g.h - 1;
-	else
-		rely = r->g.y + r->g.h - win->g.y - 1;
+	if (wx < win->g.w / 2) 
+		left = 1;
+
+	if (wy < win->g.h / 2)
+		top = 1;
+
+	if (args->id == SWM_ARG_ID_CENTER)
+		shape = XC_sizing;
+	else if (top)
+		shape = (left) ? XC_top_left_corner : XC_top_right_corner;
+	else 
+		shape = (left) ? XC_bottom_left_corner : XC_bottom_right_corner;
+
+	cursor = XCreateFontCursor(display, shape);
+
+	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
+	    GrabModeAsync, None, cursor, CurrentTime) != GrabSuccess) {
+	    	XFreeCursor(display, cursor);
+		return;
+	}
 
-	XWarpPointer(display, None, win->id, 0, 0, 0, 0, relx, rely);
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
-		switch(ev.type) {
+		switch (ev.type) {
 		case ConfigureRequest:
 		case Expose:
 		case MapRequest:
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
-			/* do not allow resize outside of region */
-			if (	ev.xmotion.x_root < r->g.x ||
-				ev.xmotion.x_root > r->g.x + r->g.w - 1 ||
-				ev.xmotion.y_root < r->g.y ||
-				ev.xmotion.y_root > r->g.y + r->g.h - 1)
-				continue;
+			/* cursor offset/delta from start of the operation */
+			dx = ev.xmotion.x_root - x;
+			dy = ev.xmotion.y_root - y;
+
+			/* vertical */
+			if (top)
+				dy = -dy;
+
+			if (args->id == SWM_ARG_ID_CENTER) {
+				if (g.h / 2 + dy < 1)
+					dy = 1 - g.h / 2;
 
-			if (ev.xmotion.x <= 1)
-				ev.xmotion.x = 1;
-			if (ev.xmotion.y <= 1)
-				ev.xmotion.y = 1;
-			win->g.w = ev.xmotion.x + 1;
-			win->g.h = ev.xmotion.y + 1;
+				win->g.y = g.y - dy;
+				win->g.h = g.h + 2 * dy;
+			} else {
+				if (g.h + dy < 1)
+					dy = 1 - g.h;
+
+				if (top)
+					win->g.y = g.y - dy;
+
+				win->g.h = g.h + dy;
+			}
+
+			/* horizontal */
+			if (left) 
+				dx = -dx;
+
+			if (args->id == SWM_ARG_ID_CENTER) {
+				if (g.w / 2 + dx < 1)
+					dx = 1 - g.w / 2;
+
+				win->g.x = g.x - dx;
+				win->g.w = g.w + 2 * dx;
+			} else {
+				if (g.w + dx < 1)
+					dx = 1 - g.w;
+
+				if (left)
+					win->g.x = g.x - dx;
+
+				win->g.w = g.w + dx;
+			}
+
+			constrain_window(win, r, 1);
 
 			/* not free, don't sync more than 120 times / second */
 			if ((ev.xmotion.time - time) > (1000 / 120) ) {
 				time = ev.xmotion.time;
 				XSync(display, False);
-				resize_window(win, args->id);
+				update_window(win);
 			}
 			break;
 		}
 	} while (ev.type != ButtonRelease);
 	if (time) {
 		XSync(display, False);
-		resize_window(win, args->id);
+		update_window(win);
 	}
 	store_float_geom(win,r);
 
-	XWarpPointer(display, None, win->id, 0, 0, 0, 0, win->g.w - 1,
-	    win->g.h - 1);
 	XUngrabPointer(display, CurrentTime);
+	XFreeCursor(display, cursor);
 
 	/* drain events */
 	drain_enter_notify();
 }
 
 void
-move_window(struct ws_win *win)
+resize_step(struct swm_region *r, union arg *args)
 {
-	unsigned int		mask;
-	XWindowChanges		wc;
-	struct swm_region	*r;
-
-	r = root_to_region(win->wa.root);
-	bzero(&wc, sizeof wc);
-	mask = CWX | CWY;
-	wc.x = win->g.x;
-	wc.y = win->g.y;
-	wc.border_width = border_width;
+	struct ws_win		*win = NULL;
 
-	DNPRINTF(SWM_D_STACK, "move_window: win %lu x %d y %d w %d h %d\n",
-	    win->id, wc.x, wc.y, wc.width, wc.height);
+	if (r && r->ws && r->ws->focus)
+		win = r->ws->focus;
+	else
+		return;
 
-	XConfigureWindow(display, win->id, mask, &wc);
+	resize(win, args);
 }
 
+#define SWM_MOVE_STEPS	(50)
+
 void
 move(struct ws_win *win, union arg *args)
 {
 	XEvent			ev;
 	Time			time = 0;
-	struct swm_region	*r = win->ws->r;
+	int			move_step = 0;
+	struct swm_region	*r = NULL;
+
+	Window			rr, cr;
+	int			x, y, wx, wy;
+	unsigned int		mask;
+
+	if (win == NULL)
+		return;
+	r = win->ws->r;
 
 	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
@@ -3340,51 +3966,95 @@ move(struct ws_win *win, union arg *args)
 
 	stack();
 
+	move_step = 0;
+	switch (args->id) {
+	case SWM_ARG_ID_MOVELEFT:
+		win->g.x -= (SWM_MOVE_STEPS - border_width);
+		move_step = 1;
+		break;
+	case SWM_ARG_ID_MOVERIGHT:
+		win->g.x += (SWM_MOVE_STEPS - border_width);
+		move_step = 1;
+		break;
+	case SWM_ARG_ID_MOVEUP:
+		win->g.y -= (SWM_MOVE_STEPS - border_width);
+		move_step = 1;
+		break;
+	case SWM_ARG_ID_MOVEDOWN:
+		win->g.y += (SWM_MOVE_STEPS - border_width);
+		move_step = 1;
+		break;
+	default:
+		break;
+	}
+	if (move_step) {
+		constrain_window(win, r, 0);
+		update_window(win);
+		store_float_geom(win,r);
+		return;
+	}
+
 	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
-	    GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
+	    GrabModeAsync, None, XCreateFontCursor(display, XC_fleur),
+	    CurrentTime) != GrabSuccess)
 		return;
-	XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0);
+
+	/* get cursor offset from window root */
+	if (!XQueryPointer(display, win->id, &rr, &cr, &x, &y, &wx, &wy, &mask))
+	    return;
+
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
-		switch(ev.type) {
+		switch (ev.type) {
 		case ConfigureRequest:
 		case Expose:
 		case MapRequest:
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
-			/* don't allow to move window origin out of region */
-			if (	ev.xmotion.x_root < r->g.x ||
-				ev.xmotion.x_root > r->g.x + r->g.w - 1 ||
-				ev.xmotion.y_root < r->g.y ||
-				ev.xmotion.y_root > r->g.y + r->g.h - 1)
-				continue;
+			win->g.x = ev.xmotion.x_root - wx - border_width;
+			win->g.y = ev.xmotion.y_root - wy - border_width;
 
-			win->g.x = ev.xmotion.x_root - border_width;
-			win->g.y = ev.xmotion.y_root - border_width;
+			constrain_window(win, r, 0);
 
 			/* not free, don't sync more than 120 times / second */
 			if ((ev.xmotion.time - time) > (1000 / 120) ) {
 				time = ev.xmotion.time;
 				XSync(display, False);
-				move_window(win);
+				update_window(win);
 			}
 			break;
 		}
 	} while (ev.type != ButtonRelease);
 	if (time) {
 		XSync(display, False);
-		move_window(win);
+		update_window(win);
 	}
 	store_float_geom(win,r);
-	XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0);
 	XUngrabPointer(display, CurrentTime);
 
 	/* drain events */
 	drain_enter_notify();
 }
 
+void
+move_step(struct swm_region *r, union arg *args)
+{
+	struct ws_win		*win = NULL;
+
+	if (r && r->ws && r->ws->focus)
+		win = r->ws->focus;
+	else
+		return;
+
+	if (!(win->transient != 0 || win->floating != 0))
+		return;
+
+	move(win, args);
+}
+
+
 /* user/key callable function IDs */
 enum keyfuncid {
 	kf_cycle_layout,
@@ -3417,6 +4087,8 @@ enum keyfuncid {
 	kf_ws_10,
 	kf_ws_next,
 	kf_ws_prev,
+	kf_ws_next_all,
+	kf_ws_prev_all,
 	kf_ws_prior,
 	kf_screen_next,
 	kf_screen_prev,
@@ -3442,6 +4114,19 @@ enum keyfuncid {
 	kf_spawn_custom,
 	kf_iconify,
 	kf_uniconify,
+	kf_raise_toggle,
+	kf_button2,
+	kf_width_shrink,
+	kf_width_grow,
+	kf_height_shrink,
+	kf_height_grow,
+	kf_move_left,
+	kf_move_right,
+	kf_move_up,
+	kf_move_down,
+	kf_name_workspace,
+	kf_search_workspace,
+	kf_search_win,
 	kf_dumpwins, /* MUST BE LAST */
 	kf_invalid
 };
@@ -3493,6 +4178,8 @@ struct keyfunc {
 	{ "ws_10",		switchws,	{.id = 9} },
 	{ "ws_next",		cyclews,	{.id = SWM_ARG_ID_CYCLEWS_UP} },
 	{ "ws_prev",		cyclews,	{.id = SWM_ARG_ID_CYCLEWS_DOWN} },
+	{ "ws_next_all",	cyclews,	{.id = SWM_ARG_ID_CYCLEWS_UP_ALL} },
+	{ "ws_prev_all",	cyclews,	{.id = SWM_ARG_ID_CYCLEWS_DOWN_ALL} },
 	{ "ws_prior",		priorws,	{0} },
 	{ "screen_next",	cyclescr,	{.id = SWM_ARG_ID_CYCLESC_UP} },
 	{ "screen_prev",	cyclescr,	{.id = SWM_ARG_ID_CYCLESC_DOWN} },
@@ -3518,6 +4205,19 @@ struct keyfunc {
 	{ "spawn_custom",	dummykeyfunc,	{0} },
 	{ "iconify",		iconify,	{0} },
 	{ "uniconify",		uniconify,	{0} },
+	{ "raise_toggle",	raise_toggle,	{0} },
+	{ "button2",		pressbutton,	{2} },
+	{ "width_shrink",	resize_step,	{.id = SWM_ARG_ID_WIDTHSHRINK} },
+	{ "width_grow",		resize_step,	{.id = SWM_ARG_ID_WIDTHGROW} },
+	{ "height_shrink",	resize_step,	{.id = SWM_ARG_ID_HEIGHTSHRINK} },
+	{ "height_grow",	resize_step,	{.id = SWM_ARG_ID_HEIGHTGROW} },
+	{ "move_left",		move_step,	{.id = SWM_ARG_ID_MOVELEFT} },
+	{ "move_right",		move_step,	{.id = SWM_ARG_ID_MOVERIGHT} },
+	{ "move_up",		move_step,	{.id = SWM_ARG_ID_MOVEUP} },
+	{ "move_down",		move_step,	{.id = SWM_ARG_ID_MOVEDOWN} },
+	{ "name_workspace",	name_workspace,	{0} },
+	{ "search_workspace",	search_workspace,	{0} },
+	{ "search_win",		search_win,	{0} },
 	{ "dumpwins",		dumpwins,	{0} }, /* MUST BE LAST */
 	{ "invalid key func",	NULL,		{0} },
 };
@@ -3664,7 +4364,7 @@ spawn_custom(struct swm_region *r, union arg *args, char *spawn_name)
 		return;
 	a.argv = real_args;
 	if (fork() == 0)
-		spawn(r, &a, 1);
+		spawn(r->ws->idx, &a, 1);
 
 	for (i = 0; i < spawn_argc; i++)
 		free(real_args[i]);
@@ -3695,12 +4395,12 @@ spawn_select(struct swm_region *r, union arg *args, char *spawn_name, int *pid)
 		break;
 	case 0: /* child */
 		if (dup2(select_list_pipe[0], 0) == -1)
-			errx(1, "dup2");
+			err(1, "dup2");
 		if (dup2(select_resp_pipe[1], 1) == -1)
-			errx(1, "dup2");
+			err(1, "dup2");
 		close(select_list_pipe[1]);
 		close(select_resp_pipe[0]);
-		spawn(r, &a, 0);
+		spawn(r->ws->idx, &a, 0);
 		break;
 	default: /* parent */
 		close(select_list_pipe[0]);
@@ -3821,8 +4521,9 @@ setconfspawn(char *selector, char *value, int flags)
 			cp += (long)strspn(cp, " \t");
 		if (strlen(word) > 0) {
 			prog->argc++;
-			prog->argv = realloc(prog->argv,
-			    prog->argc * sizeof(char *));
+			if ((prog->argv = realloc(prog->argv,
+			    prog->argc * sizeof(char *))) == NULL)
+				err(1, "setconfspawn: realloc");
 			if ((prog->argv[prog->argc - 1] = strdup(word)) == NULL)
 				err(1, "setconfspawn: strdup");
 		}
@@ -3849,13 +4550,20 @@ setup_spawn(void)
 					" -nf $bar_font_color"
 					" -sb $bar_border"
 					" -sf $bar_color",	0);
-	setconfspawn("uniconify",	"dmenu"
+	setconfspawn("search",		"dmenu"
 					" -i"
 					" -fn $bar_font"
 					" -nb $bar_color"
 					" -nf $bar_font_color"
 					" -sb $bar_border"
 					" -sf $bar_color",	0);
+	setconfspawn("name_workspace",	"dmenu"
+					" -p Workspace"
+					" -fn $bar_font"
+					" -nb $bar_color"
+					" -nf $bar_font_color"
+					" -sb $bar_border"
+					" -sf $bar_color",	0);
 }
 
 /* key bindings */
@@ -3921,7 +4629,8 @@ strdupsafe(char *str)
 }
 
 void
-setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name)
+setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid,
+    char *spawn_name)
 {
 	int			i, j;
 	DNPRINTF(SWM_D_KEY, "setkeybinding: enter %s [%s]\n",
@@ -3968,7 +4677,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 		keys_size = 4;
 		DNPRINTF(SWM_D_KEY, "setkeybinding: init list %d\n", keys_size);
 		keys = malloc((size_t)keys_size * sizeof(struct key));
-		if (!keys) {
+		if (keys == NULL) {
 			fprintf(stderr, "malloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -3977,7 +4686,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 		keys_size *= 2;
 		DNPRINTF(SWM_D_KEY, "setkeybinding: grow list %d\n", keys_size);
 		keys = realloc(keys, (size_t)keys_size * sizeof(struct key));
-		if (!keys) {
+		if (keys == NULL) {
 			fprintf(stderr, "realloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -3993,7 +4702,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 		keys[j].spawn_name = strdupsafe(spawn_name);
 	} else {
 		fprintf(stderr, "keys array problem?\n");
-		if (!keys) {
+		if (keys == NULL) {
 			fprintf(stderr, "keys array problem\n");
 			quit(NULL, NULL);
 		}
@@ -4065,7 +4774,7 @@ setup_keys(void)
 	setkeybinding(MODKEY|ShiftMask,	XK_j,		kf_swap_next,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_k,		kf_swap_prev,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_Return,	kf_spawn_term,	NULL);
-	setkeybinding(MODKEY,		XK_p,		kf_spawn_custom,	"menu");
+	setkeybinding(MODKEY,		XK_p,		kf_spawn_custom,"menu");
 	setkeybinding(MODKEY|ShiftMask,	XK_q,		kf_quit,	NULL);
 	setkeybinding(MODKEY,		XK_q,		kf_restart,	NULL);
 	setkeybinding(MODKEY,		XK_m,		kf_focus_main,	NULL);
@@ -4081,6 +4790,8 @@ setup_keys(void)
 	setkeybinding(MODKEY,		XK_0,		kf_ws_10,	NULL);
 	setkeybinding(MODKEY,		XK_Right,	kf_ws_next,	NULL);
 	setkeybinding(MODKEY,		XK_Left,	kf_ws_prev,	NULL);
+	setkeybinding(MODKEY,		XK_Up,		kf_ws_next_all,	NULL);
+	setkeybinding(MODKEY,		XK_Down,	kf_ws_prev_all,	NULL);
 	setkeybinding(MODKEY,		XK_a,		kf_ws_prior,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_Right,	kf_screen_next,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_Left,	kf_screen_prev,	NULL);
@@ -4099,20 +4810,64 @@ setup_keys(void)
 	setkeybinding(MODKEY|ShiftMask,	XK_Tab,		kf_focus_prev,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_x,		kf_wind_kill,	NULL);
 	setkeybinding(MODKEY,		XK_x,		kf_wind_del,	NULL);
-	setkeybinding(MODKEY,		XK_s,		kf_spawn_custom,	"screenshot_all");
-	setkeybinding(MODKEY|ShiftMask,	XK_s,		kf_spawn_custom,	"screenshot_wind");
+	setkeybinding(MODKEY,		XK_s,		kf_spawn_custom,"screenshot_all");
+	setkeybinding(MODKEY|ShiftMask,	XK_s,		kf_spawn_custom,"screenshot_wind");
 	setkeybinding(MODKEY,		XK_t,		kf_float_toggle,NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_v,		kf_version,	NULL);
-	setkeybinding(MODKEY|ShiftMask,	XK_Delete,	kf_spawn_custom,	"lock");
-	setkeybinding(MODKEY|ShiftMask,	XK_i,		kf_spawn_custom,	"initscr");
+	setkeybinding(MODKEY|ShiftMask,	XK_Delete,	kf_spawn_custom,"lock");
+	setkeybinding(MODKEY|ShiftMask,	XK_i,		kf_spawn_custom,"initscr");
 	setkeybinding(MODKEY,		XK_w,		kf_iconify,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_w,		kf_uniconify,	NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_r,		kf_raise_toggle,NULL);
+	setkeybinding(MODKEY,		XK_v,		kf_button2,	NULL);
+	setkeybinding(MODKEY,		XK_equal,	kf_width_grow,	NULL);
+	setkeybinding(MODKEY,		XK_minus,	kf_width_shrink,NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_equal,	kf_height_grow,	NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_minus,	kf_height_shrink,NULL);
+	setkeybinding(MODKEY,		XK_bracketleft,	kf_move_left,	NULL);
+	setkeybinding(MODKEY,		XK_bracketright,kf_move_right,	NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_bracketleft,	kf_move_up,	NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_bracketright,kf_move_down,	NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_slash,	kf_name_workspace,NULL);
+	setkeybinding(MODKEY,		XK_slash,	kf_search_workspace,NULL);
+	setkeybinding(MODKEY,		XK_f,		kf_search_win,	NULL);
 #ifdef SWM_DEBUG
 	setkeybinding(MODKEY|ShiftMask,	XK_d,		kf_dumpwins,	NULL);
 #endif
 }
 
 void
+clear_keys(void)
+{
+	int			i;
+
+	/* clear all key bindings, if any */
+	for (i = 0; i < keys_length; i++)
+		free(keys[i].spawn_name);
+	keys_length = 0;
+}
+
+int
+setkeymapping(char *selector, char *value, int flags)
+{
+	char			keymapping_file[PATH_MAX];
+	DNPRINTF(SWM_D_KEY, "setkeymapping: enter\n");
+	if (value[0] == '~')
+		snprintf(keymapping_file, sizeof keymapping_file, "%s/%s",
+		    pwd->pw_dir, &value[1]);
+	else
+		strlcpy(keymapping_file, value, sizeof keymapping_file);
+	clear_keys();
+	/* load new key bindings; if it fails, revert to default bindings */
+	if (conf_load(keymapping_file, SWM_CONF_KEYMAPPING)) {
+		clear_keys();
+		setup_keys();
+	}
+	DNPRINTF(SWM_D_KEY, "setkeymapping: leave\n");
+	return (0);
+}
+
+void
 updatenumlockmask(void)
 {
 	unsigned int		i, j;
@@ -4124,7 +4879,7 @@ updatenumlockmask(void)
 	for (i = 0; i < 8; i++)
 		for (j = 0; j < modmap->max_keypermod; j++)
 			if (modmap->modifiermap[i * modmap->max_keypermod + j]
-			  == XKeysymToKeycode(display, XK_Num_Lock))
+			    == XKeysymToKeycode(display, XK_Num_Lock))
 				numlockmask = (1 << i);
 
 	XFreeModifiermap(modmap);
@@ -4207,7 +4962,8 @@ parsequirks(char *qstr, unsigned long *quirk)
 			cp += (long)strspn(cp, SWM_Q_WS);
 		for (i = 0; i < LENGTH(quirkname); i++) {
 			if (!strncasecmp(name, quirkname[i], SWM_QUIRK_LEN)) {
-				DNPRINTF(SWM_D_QUIRK, "parsequirks: %s\n", name);
+				DNPRINTF(SWM_D_QUIRK,
+				    "parsequirks: %s\n", name);
 				if (i == 0) {
 					*quirk = 0;
 					return (0);
@@ -4270,7 +5026,7 @@ setquirk(const char *class, const char *name, const int quirk)
 		quirks_size = 4;
 		DNPRINTF(SWM_D_QUIRK, "setquirk: init list %d\n", quirks_size);
 		quirks = malloc((size_t)quirks_size * sizeof(struct quirk));
-		if (!quirks) {
+		if (quirks == NULL) {
 			fprintf(stderr, "setquirk: malloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -4278,8 +5034,9 @@ setquirk(const char *class, const char *name, const int quirk)
 	} else if (quirks_length == quirks_size) {
 		quirks_size *= 2;
 		DNPRINTF(SWM_D_QUIRK, "setquirk: grow list %d\n", quirks_size);
-		quirks = realloc(quirks, (size_t)quirks_size * sizeof(struct quirk));
-		if (!quirks) {
+		quirks = realloc(quirks,
+		    (size_t)quirks_size * sizeof(struct quirk));
+		if (quirks == NULL) {
 			fprintf(stderr, "setquirk: realloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -4293,7 +5050,7 @@ setquirk(const char *class, const char *name, const int quirk)
 		quirks[j].quirk = quirk;
 	} else {
 		fprintf(stderr, "quirks array problem?\n");
-		if (!quirks) {
+		if (quirks == NULL) {
 			fprintf(stderr, "quirks array problem!\n");
 			quit(NULL, NULL);
 		}
@@ -4339,18 +5096,22 @@ setup_quirks(void)
 /* conf file stuff */
 #define SWM_CONF_FILE	"scrotwm.conf"
 
-enum	{ SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_BAR_BORDER_WIDTH, SWM_S_STACK_ENABLED,
-	  SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT, SWM_S_CYCLE_EMPTY,
-	  SWM_S_CYCLE_VISIBLE, SWM_S_SS_ENABLED, SWM_S_TERM_WIDTH,
-	  SWM_S_TITLE_CLASS_ENABLED, SWM_S_TITLE_NAME_ENABLED, SWM_S_WINDOW_NAME_ENABLED,
-	  SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BORDER_WIDTH, SWM_S_BAR_FONT,
-	  SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO,
-	  SWM_S_BAR_AT_BOTTOM
+enum	{ SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_BAR_BORDER_WIDTH,
+	  SWM_S_STACK_ENABLED, SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT,
+	  SWM_S_CYCLE_EMPTY, SWM_S_CYCLE_VISIBLE, SWM_S_SS_ENABLED,
+	  SWM_S_TERM_WIDTH, SWM_S_TITLE_CLASS_ENABLED,
+	  SWM_S_TITLE_NAME_ENABLED, SWM_S_WINDOW_NAME_ENABLED, SWM_S_URGENT_ENABLED,
+	  SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BORDER_WIDTH,
+	  SWM_S_BAR_FONT, SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM,
+	  SWM_S_SS_APP, SWM_S_DIALOG_RATIO, SWM_S_BAR_AT_BOTTOM,
+	  SWM_S_VERBOSE_LAYOUT, SWM_S_BAR_JUSTIFY
 	};
 
 int
 setconfvalue(char *selector, char *value, int flags)
 {
+	int	i;
+
 	switch (flags) {
 	case SWM_S_BAR_DELAY:
 		bar_delay = atoi(value);
@@ -4364,6 +5125,16 @@ setconfvalue(char *selector, char *value, int flags)
 	case SWM_S_BAR_AT_BOTTOM:
 		bar_at_bottom = atoi(value);
 		break;
+	case SWM_S_BAR_JUSTIFY:
+		if (!strcmp(value, "left"))
+			bar_justify = SWM_BAR_JUSTIFY_LEFT;
+		else if (!strcmp(value, "center"))
+			bar_justify = SWM_BAR_JUSTIFY_CENTER;
+		else if (!strcmp(value, "right"))
+			bar_justify = SWM_BAR_JUSTIFY_RIGHT;
+		else
+			errx(1, "invalid bar_justify");
+		break;
 	case SWM_S_STACK_ENABLED:
 		stack_enabled = atoi(value);
 		break;
@@ -4398,6 +5169,9 @@ setconfvalue(char *selector, char *value, int flags)
 	case SWM_S_TITLE_NAME_ENABLED:
 		title_name_enabled = atoi(value);
 		break;
+	case SWM_S_URGENT_ENABLED:
+		urgent_enabled = atoi(value);
+		break;
 	case SWM_S_FOCUS_MODE:
 		if (!strcmp(value, "default"))
 			focus_mode = SWM_FOCUS_DEFAULT;
@@ -4406,7 +5180,7 @@ setconfvalue(char *selector, char *value, int flags)
 		else if (!strcmp(value, "synergy"))
 			focus_mode = SWM_FOCUS_SYNERGY;
 		else
-			err(1, "focus_mode");
+			errx(1, "focus_mode");
 		break;
 	case SWM_S_DISABLE_BORDER:
 		disable_border = atoi(value);
@@ -4436,6 +5210,15 @@ setconfvalue(char *selector, char *value, int flags)
 		if (dialog_ratio > 1.0 || dialog_ratio <= .3)
 			dialog_ratio = .6;
 		break;
+	case SWM_S_VERBOSE_LAYOUT:
+		verbose_layout = atoi(value);
+		for (i = 0; layouts[i].l_stack != NULL; i++) {
+			if (verbose_layout)
+				layouts[i].l_string = fancy_stacker;
+			else
+				layouts[i].l_string = plain_stacker;
+		}
+		break;
 	default:
 		return (1);
 	}
@@ -4472,22 +5255,155 @@ setconfregion(char *selector, char *value, int flags)
 	return (0);
 }
 
+int
+setautorun(char *selector, char *value, int flags)
+{
+	int			ws_id;
+	char			s[1024];
+	char			*ap, *sp = s;
+	union arg		a;
+	int			argc = 0;
+	long			pid;
+	struct pid_e		*p;
+
+	if (getenv("SWM_STARTED"))
+		return (0);
+
+	bzero(s, sizeof s);
+	if (sscanf(value, "ws[%d]:%1023c", &ws_id, s) != 2)
+		errx(1, "invalid autorun entry, should be 'ws[<idx>]:command'");
+	ws_id--;
+	if (ws_id < 0 || ws_id >= SWM_WS_MAX)
+		errx(1, "autorun: invalid workspace %d", ws_id + 1);
+
+	/*
+	 * This is a little intricate
+	 *
+	 * If the pid already exists we simply reuse it because it means it was
+	 * used before AND not claimed by manage_window.  We get away with
+	 * altering it in the parent after INSERT because this can not be a race
+	 */
+	a.argv = NULL;
+	while ((ap = strsep(&sp, " \t")) != NULL) {
+		if (*ap == '\0')
+			continue;
+		DNPRINTF(SWM_D_SPAWN, "setautorun: arg [%s]\n", ap);
+		argc++;
+		if ((a.argv = realloc(a.argv, argc * sizeof(char *))) == NULL)
+			err(1, "setautorun: realloc");
+		a.argv[argc - 1] = ap;
+	}
+
+	if ((a.argv = realloc(a.argv, (argc + 1) * sizeof(char *))) == NULL)
+		err(1, "setautorun: realloc");
+	a.argv[argc] = NULL;
+
+	if ((pid = fork()) == 0) {
+		spawn(ws_id, &a, 1);
+		/* NOTREACHED */
+		_exit(1);
+	}
+	free(a.argv);
+
+	/* parent */
+	p = find_pid(pid);
+	if (p == NULL) {
+		p = calloc(1, sizeof *p);
+		if (p == NULL)
+			return (1);
+		TAILQ_INSERT_TAIL(&pidlist, p, entry);
+	}
+
+	p->pid = pid;
+	p->ws = ws_id;
+
+	return (0);
+}
+
+int
+setlayout(char *selector, char *value, int flags)
+{
+	int			ws_id, i, x, mg, ma, si, raise;
+	int			st = SWM_V_STACK;
+	char			s[1024];
+	struct workspace	*ws;
+
+	if (getenv("SWM_STARTED"))
+		return (0);
+
+	bzero(s, sizeof s);
+	if (sscanf(value, "ws[%d]:%d:%d:%d:%d:%1023c",
+	    &ws_id, &mg, &ma, &si, &raise, s) != 6)
+		errx(1, "invalid layout entry, should be 'ws[<idx>]:"
+		    "<master_grow>:<master_add>:<stack_inc>:<always_raise>:"
+		    "<type>'");
+	ws_id--;
+	if (ws_id < 0 || ws_id >= SWM_WS_MAX)
+		errx(1, "layout: invalid workspace %d", ws_id + 1);
+
+	if (!strcasecmp(s, "vertical"))
+		st = SWM_V_STACK;
+	else if (!strcasecmp(s, "horizontal"))
+		st = SWM_H_STACK;
+	else if (!strcasecmp(s, "fullscreen"))
+		st = SWM_MAX_STACK;
+	else
+		errx(1, "invalid layout entry, should be 'ws[<idx>]:"
+		    "<master_grow>:<master_add>:<stack_inc>:<always_raise>:"
+		    "<type>'");
+
+	for (i = 0; i < ScreenCount(display); i++) {
+		ws = (struct workspace *)&screens[i].ws;
+		ws[ws_id].cur_layout = &layouts[st];
+
+		ws[ws_id].always_raise = raise;
+		if (st == SWM_MAX_STACK)
+			continue;
+
+		/* master grow */
+		for (x = 0; x < abs(mg); x++) {
+			ws[ws_id].cur_layout->l_config(&ws[ws_id],
+			    mg >= 0 ?  SWM_ARG_ID_MASTERGROW :
+			    SWM_ARG_ID_MASTERSHRINK);
+			stack();
+		}
+		/* master add */
+		for (x = 0; x < abs(ma); x++) {
+			ws[ws_id].cur_layout->l_config(&ws[ws_id],
+			    ma >= 0 ?  SWM_ARG_ID_MASTERADD :
+			    SWM_ARG_ID_MASTERDEL);
+			stack();
+		}
+		/* stack inc */
+		for (x = 0; x < abs(si); x++) {
+			ws[ws_id].cur_layout->l_config(&ws[ws_id],
+			    si >= 0 ?  SWM_ARG_ID_STACKINC :
+			    SWM_ARG_ID_STACKDEC);
+			stack();
+		}
+	}
+
+	return (0);
+}
+
 /* config options */
 struct config_option {
 	char			*optname;
-	int (*func)(char*, char*, int);
-	int funcflags;
+	int			(*func)(char*, char*, int);
+	int			funcflags;
 };
 struct config_option configopt[] = {
 	{ "bar_enabled",		setconfvalue,	SWM_S_BAR_ENABLED },
 	{ "bar_at_bottom",		setconfvalue,	SWM_S_BAR_AT_BOTTOM },
 	{ "bar_border",			setconfcolor,	SWM_S_COLOR_BAR_BORDER },
-	{ "bar_border_width",			setconfvalue,	SWM_S_BAR_BORDER_WIDTH },
+	{ "bar_border_width",		setconfvalue,	SWM_S_BAR_BORDER_WIDTH },
 	{ "bar_color",			setconfcolor,	SWM_S_COLOR_BAR },
 	{ "bar_font_color",		setconfcolor,	SWM_S_COLOR_BAR_FONT },
 	{ "bar_font",			setconfvalue,	SWM_S_BAR_FONT },
 	{ "bar_action",			setconfvalue,	SWM_S_BAR_ACTION },
 	{ "bar_delay",			setconfvalue,	SWM_S_BAR_DELAY },
+	{ "bar_justify",		setconfvalue,	SWM_S_BAR_JUSTIFY },
+	{ "keyboard_mapping",		setkeymapping,	0 },
 	{ "bind",			setconfbinding,	0 },
 	{ "stack_enabled",		setconfvalue,	SWM_S_STACK_ENABLED },
 	{ "clock_enabled",		setconfvalue,	SWM_S_CLOCK_ENABLED },
@@ -4497,6 +5413,7 @@ struct config_option configopt[] = {
 	{ "cycle_empty",		setconfvalue,	SWM_S_CYCLE_EMPTY },
 	{ "cycle_visible",		setconfvalue,	SWM_S_CYCLE_VISIBLE },
 	{ "dialog_ratio",		setconfvalue,	SWM_S_DIALOG_RATIO },
+	{ "verbose_layout",		setconfvalue,	SWM_S_VERBOSE_LAYOUT },
 	{ "modkey",			setconfmodkey,	0 },
 	{ "program",			setconfspawn,	0 },
 	{ "quirk",			setconfquirk,	0 },
@@ -4505,17 +5422,20 @@ struct config_option configopt[] = {
 	{ "screenshot_enabled",		setconfvalue,	SWM_S_SS_ENABLED },
 	{ "screenshot_app",		setconfvalue,	SWM_S_SS_APP },
 	{ "window_name_enabled",	setconfvalue,	SWM_S_WINDOW_NAME_ENABLED },
+	{ "urgent_enabled",		setconfvalue,	SWM_S_URGENT_ENABLED },
 	{ "term_width",			setconfvalue,	SWM_S_TERM_WIDTH },
 	{ "title_class_enabled",	setconfvalue,	SWM_S_TITLE_CLASS_ENABLED },
 	{ "title_name_enabled",		setconfvalue,	SWM_S_TITLE_NAME_ENABLED },
-	{ "focus_mode",			setconfvalue,   SWM_S_FOCUS_MODE },
-	{ "disable_border",		setconfvalue,   SWM_S_DISABLE_BORDER },
-	{ "border_width",		setconfvalue,   SWM_S_BORDER_WIDTH },
+	{ "focus_mode",			setconfvalue,	SWM_S_FOCUS_MODE },
+	{ "disable_border",		setconfvalue,	SWM_S_DISABLE_BORDER },
+	{ "border_width",		setconfvalue,	SWM_S_BORDER_WIDTH },
+	{ "autorun",			setautorun,	0 },
+	{ "layout",			setlayout,	0 },
 };
 
 
 int
-conf_load(char *filename)
+conf_load(char *filename, int keymapping)
 {
 	FILE			*config;
 	char			*line, *cp, *optsub, *optval;
@@ -4530,7 +5450,7 @@ conf_load(char *filename)
 		return (1);
 	}
 	if ((config = fopen(filename, "r")) == NULL) {
-		warn("conf_load: fopen");
+		warn("conf_load: fopen: %s", filename);
 		return (1);
 	}
 
@@ -4554,7 +5474,7 @@ conf_load(char *filename)
 		if (wordlen == 0) {
 			warnx("%s: line %zd: no option found",
 			    filename, lineno);
-			return (1);
+			goto out;
 		}
 		optind = -1;
 		for (i = 0; i < LENGTH(configopt); i++) {
@@ -4568,7 +5488,12 @@ conf_load(char *filename)
 		if (optind == -1) {
 			warnx("%s: line %zd: unknown option %.*s",
 			    filename, lineno, wordlen, cp);
-			return (1);
+			goto out;
+		}
+		if (keymapping && strcmp(opt->optname, "bind")) {
+			warnx("%s: line %zd: invalid option %.*s",
+			    filename, lineno, wordlen, cp);
+			goto out;
 		}
 		cp += wordlen;
 		cp += strspn(cp, " \t\n"); /* eat whitespace */
@@ -4581,9 +5506,16 @@ conf_load(char *filename)
 				if (wordlen == 0) {
 					warnx("%s: line %zd: syntax error",
 					    filename, lineno);
+					goto out;
+				}
+
+				if(asprintf(&optsub, "%.*s", wordlen, cp) ==
+				    -1) {
+					warnx("%s: line %zd: unable to allocate"
+					    "memory for selector", filename,
+					    lineno);
 					return (1);
 				}
-				asprintf(&optsub, "%.*s", wordlen, cp);
 			}
 			cp += wordlen;
 			cp += strspn(cp, "] \t\n"); /* eat trailing */
@@ -4608,6 +5540,12 @@ conf_load(char *filename)
 	DNPRINTF(SWM_D_CONF, "conf_load end\n");
 
 	return (0);
+
+out:
+	free(line);
+	fclose(config);
+
+	return (1);
 }
 
 void
@@ -4659,6 +5597,52 @@ set_child_transient(struct ws_win *win, Window *trans)
 		XFree(wmh);
 }
 
+long
+window_get_pid(Window win)
+{
+	Atom			actual_type_return;
+	int			actual_format_return = 0;
+	unsigned long		nitems_return = 0;
+	unsigned long		bytes_after_return = 0;
+	long			*pid = NULL;
+	long			ret = 0;
+	const char		*errstr;
+	unsigned char		*prop = NULL;
+
+	if (XGetWindowProperty(display, win,
+	    XInternAtom(display, "_NET_WM_PID", False), 0, 1, False,
+	    XA_CARDINAL, &actual_type_return, &actual_format_return,
+	    &nitems_return, &bytes_after_return,
+	    (unsigned char**)(void*)&pid) != Success)
+		goto tryharder;
+	if (actual_type_return != XA_CARDINAL)
+		goto tryharder;
+	if (pid == NULL)
+		goto tryharder;
+
+	ret = *pid;
+	XFree(pid);
+
+	return (ret);
+
+tryharder:
+	if (XGetWindowProperty(display, win,
+	    XInternAtom(display, "_SWM_PID", False), 0, SWM_PROPLEN, False,
+	    XA_STRING, &actual_type_return, &actual_format_return,
+	    &nitems_return, &bytes_after_return, &prop) != Success)
+		return (0);
+	if (actual_type_return != XA_STRING)
+		return (0);
+	if (prop == NULL)
+		return (0);
+
+	ret = strtonum((const char *)prop, 0, UINT_MAX, &errstr);
+	/* ignore error because strtonum returns 0 anyway */
+	XFree(prop);
+
+	return (ret);
+}
+
 struct ws_win *
 manage_window(Window id)
 {
@@ -4674,6 +5658,7 @@ manage_window(Window id)
 	long			mask;
 	const char		*errstr;
 	XWindowChanges		wc;
+	struct pid_e		*p;
 
 	if ((win = find_window(id)) != NULL)
 		return (win);	/* already being managed */
@@ -4694,15 +5679,19 @@ manage_window(Window id)
 	}
 
 	if ((win = calloc(1, sizeof(struct ws_win))) == NULL)
-		errx(1, "calloc: failed to allocate memory for new window");
+		err(1, "calloc: failed to allocate memory for new window");
 
 	win->id = id;
 
+	/* see if we need to override the workspace */
+	p = find_pid(window_get_pid(id));
+
 	/* Get all the window data in one shot */
 	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
-	if (ws_idx_atom)
+	if (ws_idx_atom) {
 		XGetWindowProperty(display, id, ws_idx_atom, 0, SWM_PROPLEN,
 		    False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
+	}
 	XGetWindowAttributes(display, id, &win->wa);
 	XGetWMNormalHints(display, id, &win->sh, &mask);
 	win->hints = XGetWMHints(display, id);
@@ -4734,9 +5723,14 @@ manage_window(Window id)
 	 * transient, * put it in the same workspace
 	 */
 	r = root_to_region(win->wa.root);
-	if (prop && win->transient == 0) {
+	if (p) {
+		ws = &r->s->ws[p->ws];
+		TAILQ_REMOVE(&pidlist, p, entry);
+		free(p);
+		p = NULL;
+	} else if (prop && win->transient == 0) {
 		DNPRINTF(SWM_D_PROP, "got property _SWM_WS=%s\n", prop);
-		ws_idx = strtonum(prop, 0, 9, &errstr);
+		ws_idx = strtonum((const char *)prop, 0, 9, &errstr);
 		if (errstr) {
 			DNPRINTF(SWM_D_EVENT, "window idx is %s: %s",
 			    errstr, prop);
@@ -4777,7 +5771,8 @@ manage_window(Window id)
 
 	/* Set window properties so we can remember this after reincarnation */
 	if (ws_idx_atom && prop == NULL &&
-	    snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) < SWM_PROPLEN) {
+	    snprintf((char *)ws_idx_str, SWM_PROPLEN, "%d", ws->idx) <
+	        SWM_PROPLEN) {
 		DNPRINTF(SWM_D_PROP, "setting property _SWM_WS to %s\n",
 		    ws_idx_str);
 		XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
@@ -4964,8 +5959,8 @@ keypress(XEvent *e)
 	keysym = XKeycodeToKeysym(display, (KeyCode)ev->keycode, 0);
 	for (i = 0; i < keys_length; i++)
 		if (keysym == keys[i].keysym
-		   && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
-		   && keyfuncs[keys[i].funcid].func) {
+		    && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
+		    && keyfuncs[keys[i].funcid].func) {
 			if (keys[i].funcid == kf_spawn_custom)
 				spawn_custom(
 				    root_to_region(ev->root),
@@ -4989,7 +5984,6 @@ buttonpress(XEvent *e)
 
 	DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window);
 
-	action = root_click;
 	if ((win = find_window(ev->window)) == NULL)
 		return;
 
@@ -5095,6 +6089,11 @@ enternotify(XEvent *e)
 	    ev->window, ev->mode, ev->detail, ev->root, ev->subwindow,
 	    ev->same_screen, ev->focus, ev->state);
 
+	if (ev->mode != NotifyNormal) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: generated by cursor grab.\n");
+		return;
+	}
+
 	switch (focus_mode) {
 	case SWM_FOCUS_DEFAULT:
 		break;
@@ -5294,8 +6293,8 @@ propertynotify(XEvent *e)
 	struct ws_win		*win;
 	XPropertyEvent		*ev = &e->xproperty;
 
-	DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu\n",
-	    ev->window);
+	DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu atom:%s\n",
+	    ev->window, XGetAtomName(display, ev->atom));
 
 	win = find_window(ev->window);
 	if (win == NULL)
@@ -5310,8 +6309,8 @@ propertynotify(XEvent *e)
 	}
 
 	switch (ev->atom) {
-	case XA_WM_NORMAL_HINTS:
 #if 0
+	case XA_WM_NORMAL_HINTS:
 		long		mask;
 		XGetWMNormalHints(display, win->id, &win->sh, &mask);
 		fprintf(stderr, "normal hints: flag 0x%x\n", win->sh.flags);
@@ -5323,6 +6322,11 @@ propertynotify(XEvent *e)
 		XMoveResizeWindow(display, win->id,
 		    win->g.x, win->g.y, win->g.w, win->g.h);
 #endif
+	case XA_WM_CLASS:
+		if (title_name_enabled || title_class_enabled)
+			bar_update();
+		break;
+	case XA_WM_NAME:
 		if (window_name_enabled)
 			bar_update();
 		break;
@@ -5409,7 +6413,8 @@ clientmessage(XEvent *e)
 			XKillClient(display, win->id);
 	}
 	if (ev->message_type == ewmh[_NET_MOVERESIZE_WINDOW].atom) {
-		DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_MOVERESIZE_WINDOW \n");
+		DNPRINTF(SWM_D_EVENT,
+		    "clientmessage: _NET_MOVERESIZE_WINDOW \n");
 		if (win->floating) {
 			if (ev->data.l[0] & (1<<8)) /* x */
 				win->g.x = ev->data.l[1];
@@ -5429,7 +6434,8 @@ clientmessage(XEvent *e)
 		DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_WM_STATE \n");
 		ewmh_update_win_state(win, ev->data.l[1], ev->data.l[0]);
 		if (ev->data.l[2])
-			ewmh_update_win_state(win, ev->data.l[2], ev->data.l[0]);
+			ewmh_update_win_state(win, ev->data.l[2],
+			    ev->data.l[0]);
 
 		stack();
 	}
@@ -5515,7 +6521,7 @@ new_region(struct swm_screen *s, int x, int y, int w, int h)
 			ws = r->ws;
 	} else
 		if ((r = calloc(1, sizeof(struct swm_region))) == NULL)
-			errx(1, "calloc: failed to allocate memory for screen");
+			err(1, "calloc: failed to allocate memory for screen");
 
 	/* if we don't have a workspace already, find one */
 	if (ws == NULL) {
@@ -5527,7 +6533,7 @@ new_region(struct swm_screen *s, int x, int y, int w, int h)
 	}
 
 	if (ws == NULL)
-		errx(1, "no free workspaces\n");
+		errx(1, "no free workspaces");
 
 	X(r) = x;
 	Y(r) = y;
@@ -5616,7 +6622,7 @@ screenchange(XEvent *e) {
 		if (screens[i].root == xe->root)
 			break;
 	if (i >= ScreenCount(display))
-		errx(1, "screenchange: screen not found\n");
+		errx(1, "screenchange: screen not found");
 
 	/* brute force for now, just re-enumerate the regions */
 	scan_xrandr(i);
@@ -5681,13 +6687,10 @@ setup_screens(void)
 	int			i, j, k;
 	int			errorbase, major, minor;
 	struct workspace	*ws;
-	int			ws_idx_atom;
 
 	if ((screens = calloc(ScreenCount(display),
 	     sizeof(struct swm_screen))) == NULL)
-		errx(1, "calloc: screens");
-
-	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
+		err(1, "calloc: screens");
 
 	/* initial Xrandr setup */
 	xrandr_support = XRRQueryExtension(display,
@@ -5720,6 +6723,7 @@ setup_screens(void)
 		for (j = 0; j < SWM_WS_MAX; j++) {
 			ws = &screens[i].ws[j];
 			ws->idx = j;
+			ws->name = NULL;
 			ws->focus = NULL;
 			ws->r = NULL;
 			ws->old_r = NULL;
@@ -5731,6 +6735,7 @@ setup_screens(void)
 					layouts[k].l_config(ws,
 					    SWM_ARG_ID_STACKINIT);
 			ws->cur_layout = &layouts[0];
+			ws->cur_layout->l_string(ws);
 		}
 
 		scan_xrandr(i);
@@ -5756,7 +6761,7 @@ setup_globals(void)
 	if ((spawn_term[0] = strdup("xterm")) == NULL)
 		err(1, "setup_globals: strdup");
 	if ((clock_format = strdup("%a %b %d %R %Z %Y")) == NULL)
-		errx(1, "strdup");
+		err(1, "strdup");
 }
 
 void
@@ -5788,7 +6793,6 @@ workaround(void)
 int
 main(int argc, char *argv[])
 {
-	struct passwd		*pwd;
 	struct swm_region	*r, *rr;
 	struct ws_win		*winfocus = NULL;
 	struct timeval		tv;
@@ -5801,9 +6805,10 @@ main(int argc, char *argv[])
 	struct sigaction	sact;
 
 	start_argv = argv;
-	fprintf(stderr, "Welcome to scrotwm V%s cvs tag: %s\n",
-	    SWM_VERSION, cvstag);
-	if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
+	fprintf(stderr, "Welcome to scrotwm V%s Build: %s\n",
+	    SCROTWM_VERSION, buildstr);
+	if (!setlocale(LC_CTYPE, "") || !setlocale(LC_TIME, "") ||
+	    !XSupportsLocale())
 		warnx("no locale support");
 
 	if (!(display = XOpenDisplay(0)))
@@ -5831,6 +6836,7 @@ main(int argc, char *argv[])
 	adelete = XInternAtom(display, "WM_DELETE_WINDOW", False);
 	takefocus = XInternAtom(display, "WM_TAKE_FOCUS", False);
 	a_wmname = XInternAtom(display, "WM_NAME", False);
+	a_netwmname = XInternAtom(display, "_NET_WM_NAME", False);
 	a_utf8_string = XInternAtom(display, "UTF8_STRING", False);
 	a_string = XInternAtom(display, "STRING", False);
 	a_swm_iconic = XInternAtom(display, "_SWM_ICONIC", False);
@@ -5859,15 +6865,17 @@ main(int argc, char *argv[])
 				cfile = conf;
 	}
 	if (cfile)
-		conf_load(cfile);
+		conf_load(cfile, SWM_CONF_DEFAULT);
 
 	setup_ewmh();
 	/* set some values to work around bad programs */
 	workaround();
-
 	/* grab existing windows (before we build the bars) */
 	grab_windows();
 
+	if (getenv("SWM_STARTED") == NULL)
+		setenv("SWM_STARTED", "YES", 1);
+
 	/* setup all bars */
 	for (i = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {