X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=54503c65b0068cf498fbc378b095b7eb39c796be;hb=7b5a1d5df307a1721946688ac1be98026f64afcc;hp=b9e6c22d83d9b10e2243a23c04067cf45209106a;hpb=6c9491c6a7db0b80f4c4c2404128ce7fd23c07b3;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index b9e6c22..54503c6 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -1,9 +1,10 @@
 /* $scrotwm$ */
 /*
- * Copyright (c) 2009 Marco Peereboom <marco@peereboom.us>
- * Copyright (c) 2009 Ryan McBride <mcbride@countersiege.com>
+ * Copyright (c) 2009-2010-2011 Marco Peereboom <marco@peereboom.us>
+ * Copyright (c) 2009-2010-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) 2011 Jason L. Wright <jason@thought.net>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -50,9 +51,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-static const char	*cvstag = "$scrotwm$";
+static const char	*cvstag =
+    "$scrotwm$";
 
-#define	SWM_VERSION	"0.9.19"
+#define	SWM_VERSION	"0.9.30"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -66,6 +68,7 @@ static const char	*cvstag = "$scrotwm$";
 #include <string.h>
 #include <util.h>
 #include <pwd.h>
+#include <paths.h>
 #include <ctype.h>
 
 #include <sys/types.h>
@@ -84,6 +87,10 @@ static const char	*cvstag = "$scrotwm$";
 #include <X11/Xutil.h>
 #include <X11/extensions/Xrandr.h>
 
+#ifdef __OSX__
+#include <osx.h>
+#endif
+
 #if RANDR_MAJOR < 1
 #  error XRandR versions less than 1.0 are not supported
 #endif
@@ -94,7 +101,7 @@ static const char	*cvstag = "$scrotwm$";
 #endif
 #endif
 
-/* #define SWM_DEBUG */
+/*#define SWM_DEBUG*/
 #ifdef SWM_DEBUG
 #define DPRINTF(x...)		do { if (swm_debug) fprintf(stderr, x); } while (0)
 #define DNPRINTF(n,x...)	do { if (swm_debug & n) fprintf(stderr, x); } while (0)
@@ -150,6 +157,10 @@ u_int32_t		swm_debug = 0
 #define SWM_MAX_FONT_STEPS	(3)
 #define WINID(w)		(w ? w->id : 0)
 
+#define SWM_FOCUS_DEFAULT	(0)
+#define SWM_FOCUS_SYNERGY	(1)
+#define SWM_FOCUS_FOLLOW	(2)
+
 #ifndef SWM_LIB
 #define SWM_LIB			"/usr/local/lib/libswmhack.so"
 #endif
@@ -159,9 +170,14 @@ Atom			astate;
 Atom			aprot;
 Atom			adelete;
 Atom			takefocus;
+Atom			a_wmname;
+Atom			a_utf8_string;
+Atom			a_string;
+Atom			a_swm_iconic;
 volatile sig_atomic_t   running = 1;
+volatile sig_atomic_t   restart_wm = 0;
 int			outputs = 0;
-int			last_focus_event = 0;
+int			last_focus_event = FocusOut;
 int			(*xerrorxlib)(Display *, XErrorEvent *);
 int			other_wm;
 int			ss_enabled = 0;
@@ -176,6 +192,13 @@ int			term_width = 0;
 int			font_adjusted = 0;
 unsigned int		mod_key = MODKEY;
 
+/* dmenu search */
+struct swm_region	*search_r;
+int			select_list_pipe[2];
+int			select_resp_pipe[2];
+pid_t			searchpid;
+volatile sig_atomic_t	search_resp;
+
 /* dialog windows */
 double			dialog_ratio = .6;
 /* status bar */
@@ -188,14 +211,21 @@ int			bar_version = 0;
 sig_atomic_t		bar_alarm = 0;
 int			bar_delay = 30;
 int			bar_enabled = 1;
+int			bar_border_width = 1;
+int			bar_at_bottom = 0;
 int			bar_extra = 1;
 int			bar_extra_running = 0;
 int			bar_verbose = 1;
 int			bar_height = 0;
 int			stack_enabled = 1;
 int			clock_enabled = 1;
+char			*clock_format = NULL;
 int			title_name_enabled = 0;
 int			title_class_enabled = 0;
+int			window_name_enabled = 0;
+int			focus_mode = SWM_FOCUS_DEFAULT;
+int			disable_border = 0;
+int			border_width = 1;
 pid_t			bar_pid;
 GC			bar_gc;
 XGCValues		bar_gcv;
@@ -226,6 +256,7 @@ struct swm_region {
 	TAILQ_ENTRY(swm_region)	entry;
 	struct swm_geometry	g;
 	struct workspace	*ws;	/* current workspace on this region */
+	struct workspace	*ws_prior; /* prior workspace on this region */
 	struct swm_screen	*s;	/* screen idx */
 	Window			bar_window;
 };
@@ -236,9 +267,15 @@ struct ws_win {
 	Window			id;
 	Window			transient;
 	struct ws_win		*child_trans;	/* transient child window */
-	struct swm_geometry	g;
+	struct swm_geometry	g;		/* current geometry */
+	struct swm_geometry	g_float;	/* geometry when floating */
+	struct swm_geometry	rg_float;	/* region geom when floating */
+	int			g_floatvalid;	/* flag: geometry in g_float is valid */
+	int			floatmaxed;	/* flag: floater was maxed in max_stack */
 	int			floating;
 	int			manual;
+	int			iconic;
+	unsigned int		ewmh_flags;
 	int			font_size_boundary[SWM_MAX_FONT_STEPS];
 	int			font_steps;
 	int			last_inc;
@@ -251,67 +288,10 @@ struct ws_win {
 	XWindowAttributes	wa;
 	XSizeHints		sh;
 	XClassHint		ch;
+	XWMHints		*hints;
 };
 TAILQ_HEAD(ws_win_list, ws_win);
 
-/* user/key callable function IDs */
-enum keyfuncid {
-	kf_cycle_layout,
-	kf_stack_reset,
-	kf_master_shrink,
-	kf_master_grow,
-	kf_master_add,
-	kf_master_del,
-	kf_stack_inc,
-	kf_stack_dec,
-	kf_swap_main,
-	kf_focus_next,
-	kf_focus_prev,
-	kf_swap_next,
-	kf_swap_prev,
-	kf_spawn_term,
-	kf_spawn_menu,
-	kf_quit,
-	kf_restart,
-	kf_focus_main,
-	kf_ws_1,
-	kf_ws_2,
-	kf_ws_3,
-	kf_ws_4,
-	kf_ws_5,
-	kf_ws_6,
-	kf_ws_7,
-	kf_ws_8,
-	kf_ws_9,
-	kf_ws_10,
-	kf_ws_next,
-	kf_ws_prev,
-	kf_screen_next,
-	kf_screen_prev,
-	kf_mvws_1,
-	kf_mvws_2,
-	kf_mvws_3,
-	kf_mvws_4,
-	kf_mvws_5,
-	kf_mvws_6,
-	kf_mvws_7,
-	kf_mvws_8,
-	kf_mvws_9,
-	kf_mvws_10,
-	kf_bar_toggle,
-	kf_wind_kill,
-	kf_wind_del,
-	kf_screenshot_all,
-	kf_screenshot_wind,
-	kf_float_toggle,
-	kf_version,
-	kf_spawn_lock,
-	kf_spawn_initscr,
-	kf_spawn_custom,
-	kf_dumpwins,
-	kf_invalid
-};
-
 /* layout handlers */
 void	stack(void);
 void	vertical_config(struct workspace *, int);
@@ -339,10 +319,13 @@ struct layout {
 	{ vertical_stack,	vertical_config,	0,	"[|]" },
 	{ horizontal_stack,	horizontal_config,	0,	"[-]" },
 	{ max_stack,		NULL,
-	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			"[ ]"},
-	{ NULL,			NULL,			0,	NULL },
+	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			"[ ]" },
+	{ NULL,			NULL,			0,	NULL  },
 };
 
+/* position of max_stack mode in the layouts array */
+#define SWM_MAX_STACK		2
+
 #define SWM_H_SLICE		(32)
 #define SWM_V_SLICE		(32)
 
@@ -399,6 +382,7 @@ union arg {
 #define SWM_ARG_ID_SWAPNEXT	(10)
 #define SWM_ARG_ID_SWAPPREV	(11)
 #define SWM_ARG_ID_SWAPMAIN	(12)
+#define SWM_ARG_ID_MOVELAST	(13)
 #define SWM_ARG_ID_MASTERSHRINK (20)
 #define SWM_ARG_ID_MASTERGROW	(21)
 #define SWM_ARG_ID_MASTERADD	(22)
@@ -421,9 +405,8 @@ union arg {
 };
 
 void	focus(struct swm_region *, union arg *);
-void	focus_magic(struct ws_win *, int);
-#define SWM_F_GENERIC		(0)
-#define SWM_F_TRANSIENT		(1)
+void	focus_magic(struct ws_win *);
+
 /* quirks */
 struct quirk {
 	char			*class;
@@ -434,10 +417,389 @@ struct quirk {
 #define SWM_Q_ANYWHERE		(1<<2)	/* don't position this window */
 #define SWM_Q_XTERM_FONTADJ	(1<<3)	/* adjust xterm fonts when resizing */
 #define SWM_Q_FULLSCREEN	(1<<4)	/* remove border */
+#define SWM_Q_FOCUSPREV		(1<<5)	/* focus on caller */
 };
 int				quirks_size = 0, quirks_length = 0;
 struct quirk			*quirks = NULL;
 
+/*
+ * Supported EWMH hints should be added to
+ * both the enum and the ewmh array
+ */
+enum { _NET_ACTIVE_WINDOW, _NET_MOVERESIZE_WINDOW, _NET_CLOSE_WINDOW,
+    _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_DOCK,
+    _NET_WM_WINDOW_TYPE_TOOLBAR, _NET_WM_WINDOW_TYPE_UTILITY,
+    _NET_WM_WINDOW_TYPE_SPLASH, _NET_WM_WINDOW_TYPE_DIALOG,
+    _NET_WM_WINDOW_TYPE_NORMAL, _NET_WM_STATE,
+    _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT,
+    _NET_WM_STATE_SKIP_TASKBAR, _NET_WM_STATE_SKIP_PAGER,
+    _NET_WM_STATE_HIDDEN, _NET_WM_STATE_ABOVE, _SWM_WM_STATE_MANUAL,
+    _NET_WM_STATE_FULLSCREEN, _NET_WM_ALLOWED_ACTIONS, _NET_WM_ACTION_MOVE,
+    _NET_WM_ACTION_RESIZE, _NET_WM_ACTION_FULLSCREEN, _NET_WM_ACTION_CLOSE,
+    SWM_EWMH_HINT_MAX };
+
+struct ewmh_hint {
+	char	*name;
+	Atom	 atom;
+} ewmh[SWM_EWMH_HINT_MAX] =	{
+    /* must be in same order as in the enum */
+    {"_NET_ACTIVE_WINDOW", None},
+    {"_NET_MOVERESIZE_WINDOW", None},
+    {"_NET_CLOSE_WINDOW", None},
+    {"_NET_WM_WINDOW_TYPE", None},
+    {"_NET_WM_WINDOW_TYPE_DOCK", None},
+    {"_NET_WM_WINDOW_TYPE_TOOLBAR", None},
+    {"_NET_WM_WINDOW_TYPE_UTILITY", None},
+    {"_NET_WM_WINDOW_TYPE_SPLASH", None},
+    {"_NET_WM_WINDOW_TYPE_DIALOG", None},
+    {"_NET_WM_WINDOW_TYPE_NORMAL", None},
+    {"_NET_WM_STATE", None},
+    {"_NET_WM_STATE_MAXIMIZED_HORZ", None},
+    {"_NET_WM_STATE_MAXIMIZED_VERT", None},
+    {"_NET_WM_STATE_SKIP_TASKBAR", None},
+    {"_NET_WM_STATE_SKIP_PAGER", None},
+    {"_NET_WM_STATE_HIDDEN", None},
+    {"_NET_WM_STATE_ABOVE", None},
+    {"_SWM_WM_STATE_MANUAL", None},
+    {"_NET_WM_STATE_FULLSCREEN", None},
+    {"_NET_WM_ALLOWED_ACTIONS", None},
+    {"_NET_WM_ACTION_MOVE", None},
+    {"_NET_WM_ACTION_RESIZE", None},
+    {"_NET_WM_ACTION_FULLSCREEN", None},
+    {"_NET_WM_ACTION_CLOSE", None},
+};
+
+void	store_float_geom(struct ws_win *win, struct swm_region *r);
+int	floating_toggle_win(struct ws_win *win);
+void	spawn_select(struct swm_region *, union arg *, char *, int *);
+
+int
+get_property(Window id, Atom atom, long count, Atom type,
+    unsigned long *n, unsigned char **data)
+{
+	int			format, status;
+	unsigned long		tmp, extra;
+	unsigned long		*nitems;
+	Atom			real;
+
+	nitems = n != NULL ? n : &tmp;
+	status = XGetWindowProperty(display, id, atom, 0L, count, False, type,
+	    &real, &format, nitems, &extra, data);
+
+	if (status != Success)
+		return False;
+	if (real != type)
+		return False;
+
+	return True;
+}
+
+void
+update_iconic(struct ws_win *win, int newv)
+{
+	int32_t v = newv;
+	Atom iprop;
+
+	win->iconic = newv;
+
+	iprop = XInternAtom(display, "_SWM_ICONIC", False);
+	if (!iprop)
+		return;
+	if (newv)
+		XChangeProperty(display, win->id, iprop, XA_INTEGER, 32,
+		    PropModeReplace, (unsigned char *)&v, 1);
+	else
+		XDeleteProperty(display, win->id, iprop);
+}
+
+int
+get_iconic(struct ws_win *win)
+{
+	int32_t v = 0;
+	int retfmt, status;
+	Atom iprop, rettype;
+	unsigned long nitems, extra;
+	unsigned char *prop = NULL;
+
+	iprop = XInternAtom(display, "_SWM_ICONIC", False);
+	if (!iprop)
+		goto out;
+	status = XGetWindowProperty(display, win->id, iprop, 0L, 1L,
+	    False, XA_INTEGER, &rettype, &retfmt, &nitems, &extra, &prop);
+	if (status != Success)
+		goto out;
+	if (rettype != XA_INTEGER || retfmt != 32)
+		goto out;
+	if (nitems != 1)
+		goto out;
+	v = *((int32_t *)prop);
+
+out:
+	if (prop != NULL)
+		XFree(prop);
+	return (v);
+}
+
+void
+setup_ewmh(void)
+{
+	int			i,j;
+	Atom			sup_list;
+
+	sup_list = XInternAtom(display, "_NET_SUPPORTED", False);
+
+	for (i = 0; i < LENGTH(ewmh); i++)
+		ewmh[i].atom = XInternAtom(display, ewmh[i].name, False);
+
+	for (i = 0; i < ScreenCount(display); i++) {
+		/* Support check window will be created by workaround(). */
+
+		/* 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,
+			    PropModeAppend, (unsigned char *)&ewmh[j].atom,1);
+	}
+}
+
+void
+teardown_ewmh(void)
+{
+	int			i, success;
+	unsigned char		*data = NULL;
+	unsigned long		n;
+	Atom			sup_check, sup_list;
+	Window			id;
+
+	sup_check = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
+	sup_list = XInternAtom(display, "_NET_SUPPORTED", False);
+
+	for (i = 0; i < ScreenCount(display); i++) {
+		/* Get the support check window and destroy it */
+		success = get_property(screens[i].root, sup_check, 1, XA_WINDOW,
+		    &n, &data);
+
+		if (success) {
+			id = data[0];
+			XDestroyWindow(display, id);
+			XDeleteProperty(display, screens[i].root, sup_check);
+			XDeleteProperty(display, screens[i].root, sup_list);
+		}
+
+		XFree(data);
+	}
+}
+
+void
+ewmh_autoquirk(struct ws_win *win)
+{
+	int			success, i;
+	unsigned long		*data = NULL;
+	unsigned long		n;
+	Atom			type;
+
+	success = get_property(win->id, ewmh[_NET_WM_WINDOW_TYPE].atom, (~0L),
+	    XA_ATOM, &n, (unsigned char **)&data);
+
+	if (!success) {
+		XFree(data);
+		return;
+	}
+
+	for (i = 0; i < n; i++) {
+		type = data[i];
+		if (type == ewmh[_NET_WM_WINDOW_TYPE_NORMAL].atom)
+			break;
+		if (type == ewmh[_NET_WM_WINDOW_TYPE_DOCK].atom ||
+		    type == ewmh[_NET_WM_WINDOW_TYPE_TOOLBAR].atom ||
+		    type == ewmh[_NET_WM_WINDOW_TYPE_UTILITY].atom) {
+			win->floating = 1;
+			win->quirks = SWM_Q_FLOAT | SWM_Q_ANYWHERE;
+			break;
+		}
+		if (type == ewmh[_NET_WM_WINDOW_TYPE_SPLASH].atom ||
+		    type == ewmh[_NET_WM_WINDOW_TYPE_DIALOG].atom) {
+			win->floating = 1;
+			win->quirks = SWM_Q_FLOAT;
+			break;
+		}
+	}
+
+	XFree(data);
+}
+
+#define SWM_EWMH_ACTION_COUNT_MAX	(6)
+#define EWMH_F_FULLSCREEN		(1<<0)
+#define EWMH_F_ABOVE			(1<<1)
+#define EWMH_F_HIDDEN			(1<<2)
+#define EWMH_F_SKIP_PAGER		(1<<3)
+#define EWMH_F_SKIP_TASKBAR		(1<<4)
+#define SWM_F_MANUAL			(1<<5)
+
+int
+ewmh_set_win_fullscreen(struct ws_win *win, int fs)
+{
+	struct swm_geometry	rg;
+
+	if (!win->ws->r)
+		return 0;
+
+	if (!win->floating)
+		return 0;
+
+	DNPRINTF(SWM_D_MISC, "ewmh_set_win_fullscreen: win 0x%lx fs: %d\n",
+	    win->id, fs);
+
+	rg = win->ws->r->g;
+
+	if (fs) {
+		store_float_geom(win, win->ws->r);
+
+		win->g.x = rg.x;
+		win->g.y = rg.y;
+		win->g.w = rg.w;
+		win->g.h = rg.h;
+	} else {
+		if (win->g_floatvalid) {
+			/* refloat at last floating relative position */
+			win->g.x = win->g_float.x - win->rg_float.x + rg.x;
+			win->g.y = win->g_float.y - win->rg_float.y + rg.y;
+			win->g.w = win->g_float.w;
+			win->g.h = win->g_float.h;
+		}
+	}
+
+	return 1;
+}
+
+void
+ewmh_update_actions(struct ws_win *win)
+{
+	Atom			actions[SWM_EWMH_ACTION_COUNT_MAX];
+	int			n = 0;
+
+	if (win == NULL)
+		return;
+
+	actions[n++] = ewmh[_NET_WM_ACTION_CLOSE].atom;
+
+	if (win->floating) {
+		actions[n++] = ewmh[_NET_WM_ACTION_MOVE].atom;
+		actions[n++] = ewmh[_NET_WM_ACTION_RESIZE].atom;
+	}
+
+	XChangeProperty(display, win->id, ewmh[_NET_WM_ALLOWED_ACTIONS].atom,
+	    XA_ATOM, 32, PropModeReplace, (unsigned char *)actions, n);
+}
+
+#define _NET_WM_STATE_REMOVE	0    /* remove/unset property */
+#define _NET_WM_STATE_ADD	1    /* add/set property */
+#define _NET_WM_STATE_TOGGLE	2    /* toggle property */
+
+void
+ewmh_update_win_state(struct ws_win *win, long state, long action)
+{
+	unsigned int		mask = 0;
+	unsigned int		changed = 0;
+	unsigned int		orig_flags;
+
+	if (win == NULL)
+		return;
+
+	if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom)
+		mask = EWMH_F_FULLSCREEN;
+	if (state == ewmh[_NET_WM_STATE_ABOVE].atom)
+		mask = EWMH_F_ABOVE;
+	if (state == ewmh[_SWM_WM_STATE_MANUAL].atom)
+		mask = SWM_F_MANUAL;
+	if (state == ewmh[_NET_WM_STATE_SKIP_PAGER].atom)
+		mask = EWMH_F_SKIP_PAGER;
+	if (state == ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom)
+		mask = EWMH_F_SKIP_TASKBAR;
+
+
+	orig_flags = win->ewmh_flags;
+
+	switch (action) {
+	case _NET_WM_STATE_REMOVE:
+		win->ewmh_flags &= ~mask;
+		break;
+	case _NET_WM_STATE_ADD:
+		win->ewmh_flags |= mask;
+		break;
+	case _NET_WM_STATE_TOGGLE:
+		win->ewmh_flags ^= mask;
+		break;
+	}
+
+	changed = (win->ewmh_flags & mask) ^ (orig_flags & mask) ? 1 : 0;
+
+	if (state == ewmh[_NET_WM_STATE_ABOVE].atom)
+		if (changed)
+			if (!floating_toggle_win(win))
+				win->ewmh_flags = orig_flags; /* revert */
+	if (state == ewmh[_SWM_WM_STATE_MANUAL].atom)
+		if (changed)
+			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))
+				win->ewmh_flags = orig_flags; /* revert */
+
+	XDeleteProperty(display, win->id, ewmh[_NET_WM_STATE].atom);
+
+	if (win->ewmh_flags & EWMH_F_FULLSCREEN)
+		XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
+		    XA_ATOM, 32, PropModeAppend,
+		    (unsigned char *)&ewmh[_NET_WM_STATE_FULLSCREEN].atom, 1);
+	if (win->ewmh_flags & EWMH_F_SKIP_PAGER)
+		XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
+		    XA_ATOM, 32, PropModeAppend,
+		    (unsigned char *)&ewmh[_NET_WM_STATE_SKIP_PAGER].atom, 1);
+	if (win->ewmh_flags & EWMH_F_SKIP_TASKBAR)
+		XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
+		    XA_ATOM, 32, PropModeAppend,
+		    (unsigned char *)&ewmh[_NET_WM_STATE_SKIP_TASKBAR].atom, 1);
+	if (win->ewmh_flags & EWMH_F_ABOVE)
+		XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
+		    XA_ATOM, 32, PropModeAppend,
+		    (unsigned char *)&ewmh[_NET_WM_STATE_ABOVE].atom, 1);
+	if (win->ewmh_flags & SWM_F_MANUAL)
+		XChangeProperty(display, win->id, ewmh[_NET_WM_STATE].atom,
+		    XA_ATOM, 32, PropModeAppend,
+		    (unsigned char *)&ewmh[_SWM_WM_STATE_MANUAL].atom, 1);
+}
+
+void
+ewmh_get_win_state(struct ws_win *win)
+{
+	int			success, i;
+	unsigned long		n;
+	Atom			*states;
+
+	if (win == NULL)
+		return;
+
+	win->ewmh_flags = 0;
+	if (win->floating)
+		win->ewmh_flags |= EWMH_F_ABOVE;
+	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);
+
+	if (!success)
+		return;
+
+	for (i = 0; i < n; i++)
+		ewmh_update_win_state(win, states[i], _NET_WM_STATE_ADD);
+
+	XFree(states);
+}
+
 /* events */
 #ifdef SWM_DEBUG
 void
@@ -576,8 +938,9 @@ dumpwins(struct swm_region *r, union arg *args)
 		if (!XGetWindowAttributes(display, win->id, &wa))
 			fprintf(stderr, "window: %lu failed "
 			    "XGetWindowAttributes\n", win->id);
-		fprintf(stderr, "window: %lu map_state: %d state: %d\n",
-		    win->id, wa.map_state, state);
+		fprintf(stderr, "window: %lu map_state: %d state: %d "
+		    "transient: %lu\n",
+		    win->id, wa.map_state, state, win->transient);
 	}
 
 	fprintf(stderr, "===== unmanaged window list =====\n");
@@ -586,8 +949,9 @@ dumpwins(struct swm_region *r, union arg *args)
 		if (!XGetWindowAttributes(display, win->id, &wa))
 			fprintf(stderr, "window: %lu failed "
 			    "XGetWindowAttributes\n", win->id);
-		fprintf(stderr, "window: %lu map_state: %d state: %d\n",
-		    win->id, wa.map_state, state);
+		fprintf(stderr, "window: %lu map_state: %d state: %d "
+		    "transient: %lu\n",
+		    win->id, wa.map_state, state, win->transient);
 	}
 
 	fprintf(stderr, "=================================\n");
@@ -614,6 +978,7 @@ void			maprequest(XEvent *);
 void			propertynotify(XEvent *);
 void			unmapnotify(XEvent *);
 void			visibilitynotify(XEvent *);
+void			clientmessage(XEvent *);
 
 void			(*handler[LASTEvent])(XEvent *) = {
 				[Expose] = expose,
@@ -631,40 +996,55 @@ void			(*handler[LASTEvent])(XEvent *) = {
 				[PropertyNotify] = propertynotify,
 				[UnmapNotify] = unmapnotify,
 				[VisibilityNotify] = visibilitynotify,
+				[ClientMessage] = clientmessage,
 };
 
 void
 sighdlr(int sig)
 {
+	int			saved_errno, status;
 	pid_t			pid;
 
+	saved_errno = errno;
+
 	switch (sig) {
 	case SIGCHLD:
-		while ((pid = waitpid(WAIT_ANY, NULL, WNOHANG)) != -1) {
-			DNPRINTF(SWM_D_MISC, "reaping: %d\n", pid);
-			if (pid <= 0)
+		while ((pid = waitpid(WAIT_ANY, &status, WNOHANG)) != 0) {
+			if (pid == -1) {
+				if (errno == EINTR)
+					continue;
+#ifdef SWM_DEBUG
+				if (errno != ECHILD)
+					warn("sighdlr: waitpid");
+#endif /* SWM_DEBUG */
 				break;
+			}
+			if (pid == searchpid)
+				search_resp = 1;
+
+#ifdef SWM_DEBUG
+			if (WIFEXITED(status)) {
+				if (WEXITSTATUS(status) != 0)
+					warnx("sighdlr: child exit status: %d",
+					    WEXITSTATUS(status));
+			} else
+				warnx("sighdlr: child is terminated "
+				    "abnormally");
+#endif /* SWM_DEBUG */
 		}
 		break;
+
+	case SIGHUP:
+		restart_wm = 1;
+		break;
 	case SIGINT:
 	case SIGTERM:
-	case SIGHUP:
 	case SIGQUIT:
 		running = 0;
 		break;
 	}
-}
 
-void
-installsignal(int sig, char *name)
-{
-	struct sigaction	sa;
-
-	sa.sa_handler = sighdlr;
-	sigemptyset(&sa.sa_mask);
-	sa.sa_flags = 0;
-	if (sigaction(sig, &sa, NULL) == -1)
-		err(1, "could not install %s handler", name);
+	errno = saved_errno;
 }
 
 unsigned long
@@ -731,10 +1111,13 @@ custom_region(char *val)
 	if (x  < 0 || x > DisplayWidth(display, sidx) ||
 	    y < 0 || y > DisplayHeight(display, sidx) ||
 	    w + x > DisplayWidth(display, sidx) ||
-	    h + y > DisplayHeight(display, sidx))
-		errx(1, "region %ux%u+%u+%u not within screen boundaries "
+	    h + y > DisplayHeight(display, sidx)) {
+		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;
+	}
 
 	new_region(&screens[sidx], x, y, w, h);
 }
@@ -805,6 +1188,23 @@ out:
 }
 
 void
+bar_window_name(char *s, ssize_t sz, struct ws_win *cur_focus)
+{
+	char			*title;
+
+	if (window_name_enabled && cur_focus != NULL) {
+		XFetchName(display, cur_focus->id, &title);
+		if (title) {
+			if (cur_focus->floating)
+				strlcat(s, "(f) ", sz);
+			strlcat(s, title, sz);
+			strlcat(s, " ", sz);
+			XFree(title);
+		}
+	}
+}
+
+void
 bar_update(void)
 {
 	time_t			tmt;
@@ -813,6 +1213,7 @@ bar_update(void)
 	int			i, x;
 	size_t			len;
 	char			s[SWM_BAR_MAX];
+	char			cn[SWM_BAR_MAX];
 	char			loc[SWM_BAR_MAX];
 	char			*b;
 	char			*stack = "";
@@ -839,20 +1240,24 @@ bar_update(void)
 	else {
 		time(&tmt);
 		localtime_r(&tmt, &tm);
-		strftime(s, sizeof s, "%a %b %d %R %Z %Y    ", &tm);
+		strftime(s, sizeof s, clock_format, &tm);
+		strlcat(s, "    ", sizeof s);
 	}
 
 	for (i = 0; i < ScreenCount(display); i++) {
 		x = 1;
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {
-			if (r && r->ws)
-				bar_class_name(s, sizeof s, r->ws->focus);
+			strlcpy(cn, "", sizeof cn);
+			if (r && r->ws) {
+				bar_class_name(cn, sizeof cn, r->ws->focus);
+				bar_window_name(cn, sizeof cn, r->ws->focus);
+			}
 
 			if (stack_enabled)
 				stack = r->ws->cur_layout->name;
 
-			snprintf(loc, sizeof loc, "%d:%d %s   %s %s    %s",
-			    x++, r->ws->idx + 1, stack, s, bar_ext,
+			snprintf(loc, sizeof loc, "%d:%d %s   %s%s    %s    %s",
+			    x++, r->ws->idx + 1, stack, s, cn, bar_ext,
 			    bar_vertext);
 			bar_print(r, loc);
 		}
@@ -942,7 +1347,12 @@ bar_refresh(void)
 void
 bar_setup(struct swm_region *r)
 {
-	int			i;
+	int			i, x, y;
+
+	if (bar_fs) {
+		XFreeFont(display, bar_fs);
+		bar_fs = NULL;
+	}
 
 	for (i = 0; bar_fonts[i] != NULL; i++) {
 		bar_fs = XLoadQueryFont(display, bar_fonts[i]);
@@ -953,11 +1363,18 @@ bar_setup(struct swm_region *r)
 	}
 	if (bar_fonts[i] == NULL)
 			errx(1, "couldn't load font");
-	bar_height = bar_fs->ascent + bar_fs->descent + 3;
+	if (bar_fs == NULL)
+		errx(1, "couldn't create font structure");
+
+	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(r), Y(r), WIDTH(r) - 2, bar_height - 2,
-	    1, r->s->c[SWM_S_COLOR_BAR_BORDER].color,
+	    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);
 	XSetFont(display, bar_gc, bar_fs->fid);
@@ -972,6 +1389,18 @@ bar_setup(struct swm_region *r)
 }
 
 void
+drain_enter_notify(void)
+{
+	int			i = 0;
+	XEvent			cne;
+
+	while (XCheckMaskEvent(display, EnterWindowMask, &cne))
+		i++;
+
+	DNPRINTF(SWM_D_MISC, "drain_enter_notify: drained %d\n", i);
+}
+
+void
 set_win_state(struct ws_win *win, long state)
 {
 	long			data[] = {state, None};
@@ -988,15 +1417,11 @@ set_win_state(struct ws_win *win, long state)
 long
 getstate(Window w)
 {
-	int			format, status;
 	long			result = -1;
 	unsigned char		*p = NULL;
-	unsigned long		n, extra;
-	Atom			real;
+	unsigned long		n;
 
-	status = XGetWindowProperty(display, w, astate, 0L, 2L, False, astate,
-	    &real, &format, &n, &extra, (unsigned char **)&p);
-	if (status != Success)
+	if (!get_property(w, astate, 2L, astate, &n, &p))
 		return (-1);
 	if (n != 0)
 		result = *((long *)p);
@@ -1035,49 +1460,46 @@ client_msg(struct ws_win *win, Atom a)
 }
 
 void
-configreq_win(struct ws_win *win)
-{
-	XConfigureRequestEvent	cr;
-
-	if (win == NULL)
-		return;
-
-	bzero(&cr, sizeof cr);
-	cr.type = ConfigureRequest;
-	cr.display = display;
-	cr.parent = win->id;
-	cr.window = win->id;
-	cr.x = win->g.x;
-	cr.y = win->g.y;
-	cr.width = win->g.w;
-	cr.height = win->g.h;
-	cr.border_width = 1;
-
-	XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&cr);
-}
-
-void
-config_win(struct ws_win *win)
+config_win(struct ws_win *win, XConfigureRequestEvent  *ev)
 {
 	XConfigureEvent		ce;
 
-	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);
-
 	if (win == NULL)
 		return;
 
-	ce.type = ConfigureNotify;
-	ce.display = display;
-	ce.event = win->id;
-	ce.window = win->id;
-	ce.x = win->g.x;
-	ce.y = win->g.y;
-	ce.width = win->g.w;
-	ce.height = win->g.h;
-	ce.border_width = 1; /* XXX store this! */
-	ce.above = None;
-	ce.override_redirect = False;
+	if (ev == NULL) {
+		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;
+		ce.display = display;
+		ce.event = win->id;
+		ce.window = win->id;
+		ce.x = win->g.x;
+		ce.y = win->g.y;
+		ce.width = win->g.w;
+		ce.height = win->g.h;
+		ce.border_width = border_width;
+		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",
+		    ev->window, ev->x, ev->y, ev->width, ev->height);
+		ce.type = ConfigureNotify;
+		ce.display = ev->display;
+		ce.event = ev->window;
+		ce.window = ev->window;
+		ce.x = ev->x;
+		ce.y = ev->y;
+		ce.width = ev->width;
+		ce.height = ev->height;
+		ce.border_width = ev->border_width;
+		ce.above = ev->above;
+		ce.override_redirect = False;
+	}
+
 	XSendEvent(display, win->id, False, StructureNotifyMask, (XEvent *)&ce);
 }
 
@@ -1092,6 +1514,8 @@ count_win(struct workspace *ws, int count_transient)
 			continue;
 		if (count_transient == 0 && win->transient)
 			continue;
+		if (win->iconic)
+			continue;
 		count++;
 	}
 	DNPRINTF(SWM_D_MISC, "count_win: %d\n", count);
@@ -1119,6 +1543,8 @@ unmap_window(struct ws_win *win)
 	set_win_state(win, IconicState);
 
 	XUnmapWindow(display, win->id);
+	XSetWindowBorder(display, win->id,
+	    win->s->c[SWM_S_COLOR_UNFOCUS].color);
 }
 
 void
@@ -1230,53 +1656,90 @@ struct ws_win *
 find_window(Window id)
 {
 	struct ws_win		*win;
+	Window			wrr, wpr, *wcr = NULL;
 	int			i, j;
+	unsigned int		nc;
 
 	for (i = 0; i < ScreenCount(display); i++)
 		for (j = 0; j < SWM_WS_MAX; j++)
 			TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
 				if (id == win->id)
 					return (win);
+
+	/* if we were looking for the parent return that window instead */
+	if (XQueryTree(display, id, &wrr, &wpr, &wcr, &nc) == 0)
+		return (NULL);
+	if (wcr)
+		XFree(wcr);
+
+	/* ignore not found and root */
+	if (wpr == 0 || wrr == wpr)
+		return (NULL);
+
+	/* look for parent */
+	for (i = 0; i < ScreenCount(display); i++)
+		for (j = 0; j < SWM_WS_MAX; j++)
+			TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
+				if (wpr == win->id)
+					return (win);
+
 	return (NULL);
 }
 
 void
-spawn(struct swm_region *r, union arg *args)
+spawn(struct swm_region *r, union arg *args, int close_fd)
 {
-	char			*ret;
-	int			si;
+	int			fd;
+	char			*ret = NULL;
 
 	DNPRINTF(SWM_D_MISC, "spawn: %s\n", args->argv[0]);
-	/*
-	 * The double-fork construct avoids zombie processes and keeps the code
-	 * clean from stupid signal handlers.
-	 */
-	if (fork() == 0) {
-		if (fork() == 0) {
-			if (display)
-				close(ConnectionNumber(display));
-			setenv("LD_PRELOAD", SWM_LIB, 1);
-			if (asprintf(&ret, "%d", r->ws->idx)) {
-				setenv("_SWM_WS", ret, 1);
-				free(ret);
-			}
-			if (asprintf(&ret, "%d", getpid())) {
-				setenv("_SWM_PID", ret, 1);
-				free(ret);
-			}
-			setsid();
-			/* kill stdin, mplayer, ssh-add etc. need that */
-			si = open("/dev/null", O_RDONLY, 0);
-			if (si == -1)
-				err(1, "open /dev/null");
-			if (dup2(si, 0) == -1)
-				err(1, "dup2 /dev/null");
-			execvp(args->argv[0], args->argv);
-			fprintf(stderr, "execvp failed\n");
-			perror(" failed");
+
+	if (display)
+		close(ConnectionNumber(display));
+
+	setenv("LD_PRELOAD", SWM_LIB, 1);
+
+	if (asprintf(&ret, "%d", r->ws->idx) == -1) {
+		perror("_SWM_WS");
+		_exit(1);
+	}
+	setenv("_SWM_WS", ret, 1);
+	free(ret);
+	ret = NULL;
+
+	if (asprintf(&ret, "%d", getpid()) == -1) {
+		perror("_SWM_PID");
+		_exit(1);
+	}
+	setenv("_SWM_PID", ret, 1);
+	free(ret);
+	ret = NULL;
+
+	if (setsid() == -1) {
+		perror("setsid");
+		_exit(1);
+	}
+
+	if (close_fd) {
+		/*
+		 * close stdin and stdout to prevent interaction between apps
+		 * and the baraction script
+		 * leave stderr open to record errors
+		*/
+		if ((fd = open(_PATH_DEVNULL, O_RDWR, 0)) == -1) {
+			perror("open");
+			_exit(1);
 		}
-		exit(0);
+		dup2(fd, STDIN_FILENO);
+		dup2(fd, STDOUT_FILENO);
+		if (fd > 2)
+			close(fd);
 	}
+
+	execvp(args->argv[0], args->argv);
+
+	perror("execvp");
+	_exit(1);
 }
 
 void
@@ -1286,7 +1749,8 @@ spawnterm(struct swm_region *r, union arg *args)
 
 	if (term_width)
 		setenv("_SWM_XTERM_FONTADJ", "", 1);
-	spawn(r, args);
+	if (fork() == 0)
+		spawn(r, args, 1);
 }
 
 void
@@ -1319,7 +1783,7 @@ validate_win(struct ws_win *testwin)
 	int			i, x, foundit = 0;
 
 	if (testwin == NULL)
-		return(0);
+		return (0);
 
 	for (i = 0, foundit = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
@@ -1353,6 +1817,9 @@ validate_ws(struct workspace *testws)
 void
 unfocus_win(struct ws_win *win)
 {
+	XEvent			cne;
+	Window			none = None;
+
 	DNPRINTF(SWM_D_FOCUS, "unfocus_win: id: %lu\n", WINID(win));
 
 	if (win == NULL)
@@ -1361,7 +1828,7 @@ unfocus_win(struct ws_win *win)
 		return;
 
 	if (validate_ws(win->ws))
-		abort();
+		return; /* XXX this gets hit with thunderbird, needs fixing */
 
 	if (win->ws->r == NULL)
 		return;
@@ -1385,31 +1852,41 @@ unfocus_win(struct ws_win *win)
 		win->ws->focus_prev = NULL;
 	}
 
+	/* drain all previous unfocus events */
+	while (XCheckTypedEvent(display, FocusOut, &cne) == True)
+		;
+
 	grabbuttons(win, 0);
 	XSetWindowBorder(display, win->id,
 	    win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+
+	XChangeProperty(display, win->s->root,
+	    ewmh[_NET_ACTIVE_WINDOW].atom, XA_WINDOW, 32,
+	    PropModeReplace, (unsigned char *)&none,1);
 }
 
 void
-unfocus_all_except(struct ws_win *except)
+unfocus_all(void)
 {
 	struct ws_win		*win;
 	int			i, j;
 
-	DNPRINTF(SWM_D_FOCUS, "unfocus_all_except: id: %lu\n", except->id);
+	DNPRINTF(SWM_D_FOCUS, "unfocus_all\n");
 
 	for (i = 0; i < ScreenCount(display); i++)
 		for (j = 0; j < SWM_WS_MAX; j++)
 			TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
-				if (win != except)
-					unfocus_win(win);
+				unfocus_win(win);
 }
 
 void
 focus_win(struct ws_win *win)
 {
-	int			rtr;
-	Window			wf;
+	XEvent			cne;
+	Window			cur_focus;
+	int			rr;
+	struct ws_win		*cfw = NULL;
+
 
 	DNPRINTF(SWM_D_FOCUS, "focus_win: id: %lu\n", win ? win->id : 0);
 
@@ -1419,41 +1896,59 @@ focus_win(struct ws_win *win)
 		return;
 
 	if (validate_ws(win->ws))
-		abort();
+		return; /* XXX this gets hit with thunderbird, needs fixing */
+
 	if (validate_win(win)) {
 		kill_refs(win);
 		return;
 	}
 
-	/* use big hammer to make sure it works under all use cases */
-	unfocus_all_except(win);
-
 	if (validate_win(win)) {
 		kill_refs(win);
 		return;
 	}
 
+	XGetInputFocus(display, &cur_focus, &rr);
+	if ((cfw = find_window(cur_focus)) != NULL)
+		unfocus_win(cfw);
+	else {
+		/* use larger hammer since the window was killed somehow */
+		TAILQ_FOREACH(cfw, &win->ws->winlist, entry)
+			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;
 
 	if (win->ws->r != NULL) {
-		XGetInputFocus(display, &wf, &rtr);
-		if (wf != win->id) {
-			grabbuttons(win, 1);
-			if (win->java == 0)
-				XSetInputFocus(display, win->id,
-				    RevertToParent, CurrentTime);
-		}
+		/* drain all previous focus events */
+		while (XCheckTypedEvent(display, FocusIn, &cne) == True)
+			;
+
+		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)
 			XMapRaised(display, win->id);
+
+		XChangeProperty(display, win->s->root,
+		    ewmh[_NET_ACTIVE_WINDOW].atom, XA_WINDOW, 32,
+		    PropModeReplace, (unsigned char *)&win->id,1);
 	}
+
+	if (window_name_enabled)
+		bar_update();
 }
 
 void
 switchws(struct swm_region *r, union arg *args)
 {
-	int			wsid = args->id;
+	int			wsid = args->id, unmap_old = 0;
 	struct swm_region	*this_r, *other_r;
 	struct ws_win		*win;
 	struct workspace	*new_ws, *old_ws;
@@ -1477,24 +1972,35 @@ switchws(struct swm_region *r, union arg *args)
 
 	other_r = new_ws->r;
 	if (other_r == NULL) {
-		/* if the other workspace is hidden, switch windows */
-		if (old_ws->r != NULL)
-			old_ws->old_r = old_ws->r;
+		/* the other workspace is hidden, hide this one */
 		old_ws->r = NULL;
-
-		TAILQ_FOREACH(win, &old_ws->winlist, entry)
-			unmap_window(win);
+		unmap_old = 1;
 	} else {
+		/* the other ws is visible in another region, exchange them */
+		other_r->ws_prior = new_ws;
 		other_r->ws = old_ws;
 		old_ws->r = other_r;
 	}
+	this_r->ws_prior = old_ws;
 	this_r->ws = new_ws;
 	new_ws->r = this_r;
 
+	/* this is needed so that we can click on a window after a restart */
+	unfocus_all();
+
 	stack();
 	a.id = SWM_ARG_ID_FOCUSCUR;
 	focus(new_ws->r, &a);
+
 	bar_update();
+
+	/* unmap old windows */
+	if (unmap_old)
+		TAILQ_FOREACH(win, &old_ws->winlist, entry)
+			unmap_window(win);
+
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
@@ -1536,6 +2042,22 @@ cyclews(struct swm_region *r, union arg *args)
 }
 
 void
+priorws(struct swm_region *r, union arg *args)
+{
+	union arg		a;
+
+	DNPRINTF(SWM_D_WS, "priorws id %d "
+	    "in screen[%d]:%dx%d+%d+%d ws %d\n", args->id,
+	    r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r), r->ws->idx);
+
+	if (r->ws_prior == NULL)
+		return;
+
+	a.id = r->ws_prior->idx;
+	switchws(r, &a);
+}
+
+void
 cyclescr(struct swm_region *r, union arg *args)
 {
 	struct swm_region	*rr = NULL;
@@ -1566,7 +2088,7 @@ cyclescr(struct swm_region *r, union arg *args)
 
 	/* move mouse to region */
 	x = rr->g.x + 1;
-	y = rr->g.y + 1 + bar_enabled ? bar_height : 0;
+	y = rr->g.y + 1 + (bar_enabled ? bar_height : 0);
 	XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, x, y);
 
 	a.id = SWM_ARG_ID_FOCUSCUR;
@@ -1581,6 +2103,29 @@ cyclescr(struct swm_region *r, union arg *args)
 }
 
 void
+sort_windows(struct ws_win_list *wl)
+{
+	struct ws_win		*win, *parent, *nxt;
+
+	if (wl == NULL)
+		return;
+
+	for (win = TAILQ_FIRST(wl); win != TAILQ_END(wl); win = nxt) {
+		nxt = TAILQ_NEXT(win, entry);
+		if (win->transient) {
+			parent = find_window(win->transient);
+			if (parent == NULL) {
+				fprintf(stderr, "not possible bug\n");
+				continue;
+			}
+			TAILQ_REMOVE(wl, win, entry);
+			TAILQ_INSERT_AFTER(wl, parent, win, entry);
+		}
+	}
+
+}
+
+void
 swapwin(struct swm_region *r, union arg *args)
 {
 	struct ws_win		*target, *source;
@@ -1601,8 +2146,12 @@ swapwin(struct swm_region *r, union arg *args)
 
 	switch (args->id) {
 	case SWM_ARG_ID_SWAPPREV:
+		if (source->transient)
+			source = find_window(source->transient);
 		target = TAILQ_PREV(source, ws_win_list, entry);
-		TAILQ_REMOVE(wl, cur_focus, entry);
+		if (target && target->transient)
+			target = find_window(target->transient);
+		TAILQ_REMOVE(wl, source, entry);
 		if (target == NULL)
 			TAILQ_INSERT_TAIL(wl, source, entry);
 		else
@@ -1610,6 +2159,9 @@ swapwin(struct swm_region *r, union arg *args)
 		break;
 	case SWM_ARG_ID_SWAPNEXT:
 		target = TAILQ_NEXT(source, entry);
+		/* move the parent and let the sort handle the move */
+		if (source->transient)
+			source = find_window(source->transient);
 		TAILQ_REMOVE(wl, source, entry);
 		if (target == NULL)
 			TAILQ_INSERT_HEAD(wl, source, entry);
@@ -1625,7 +2177,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;
@@ -1634,11 +2186,17 @@ swapwin(struct swm_region *r, union arg *args)
 		TAILQ_REMOVE(wl, source, entry);
 		TAILQ_INSERT_HEAD(wl, source, entry);
 		break;
+	case SWM_ARG_ID_MOVELAST:
+		TAILQ_REMOVE(wl, source, entry);
+		TAILQ_INSERT_TAIL(wl, source, entry);
+		break;
 	default:
 		DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id);
 		return;
 	}
 
+	sort_windows(wl);
+
 	stack();
 }
 
@@ -1678,11 +2236,12 @@ focus_prev(struct ws_win *win)
 	}
 
 	/* if in max_stack try harder */
-	if (ws->cur_layout->flags & SWM_L_FOCUSPREV) {
- 		if (cur_focus != ws->focus_prev)
- 			winfocus = ws->focus_prev;
- 		else if (cur_focus != ws->focus)
- 			winfocus = ws->focus;
+	if ((win->quirks & SWM_Q_FOCUSPREV) ||
+	    (ws->cur_layout->flags & SWM_L_FOCUSPREV)) {
+		if (cur_focus != ws->focus_prev)
+			winfocus = ws->focus_prev;
+		else if (cur_focus != ws->focus)
+			winfocus = ws->focus;
 		else
 			winfocus = TAILQ_PREV(win, ws_win_list, entry);
 		if (winfocus)
@@ -1699,13 +2258,13 @@ done:
 	if (winfocus == winlostfocus || winfocus == NULL)
 		return;
 
-	focus_magic(winfocus, SWM_F_GENERIC);
+	focus_magic(winfocus);
 }
 
 void
 focus(struct swm_region *r, union arg *args)
 {
-	struct ws_win		*winfocus = NULL, *winlostfocus = NULL;
+	struct ws_win		*winfocus = NULL, *winlostfocus = NULL, *head;
 	struct ws_win		*cur_focus = NULL;
 	struct ws_win_list	*wl = NULL;
 	struct workspace	*ws = NULL;
@@ -1717,14 +2276,16 @@ focus(struct swm_region *r, union arg *args)
 
 	/* treat FOCUS_CUR special */
 	if (args->id == SWM_ARG_ID_FOCUSCUR) {
-		if (r->ws->focus)
+		if (r->ws->focus && r->ws->focus->iconic == 0)
 			winfocus = r->ws->focus;
-		else if (r->ws->focus_prev)
+		else if (r->ws->focus_prev && r->ws->focus_prev->iconic == 0)
 			winfocus = r->ws->focus_prev;
 		else
-			winfocus = TAILQ_FIRST(&r->ws->winlist);
+			TAILQ_FOREACH(winfocus, &r->ws->winlist, entry)
+				if (winfocus->iconic == 0)
+					break;
 
-		focus_magic(winfocus, SWM_F_GENERIC);
+		focus_magic(winfocus);
 		return;
 	}
 
@@ -1736,16 +2297,38 @@ focus(struct swm_region *r, union arg *args)
 	winlostfocus = cur_focus;
 
 	switch (args->id) {
- 	case SWM_ARG_ID_FOCUSPREV:
-		winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry);
-		if (winfocus == NULL)
-			winfocus = TAILQ_LAST(wl, ws_win_list);
+	case SWM_ARG_ID_FOCUSPREV:
+		head = TAILQ_PREV(cur_focus, ws_win_list, entry);
+		if (head == NULL)
+			head = TAILQ_LAST(wl, ws_win_list);
+		winfocus = head;
+		if (WINID(winfocus) == cur_focus->transient) {
+			head = TAILQ_PREV(winfocus, ws_win_list, entry);
+			if (head == NULL)
+				head = TAILQ_LAST(wl, ws_win_list);
+			winfocus = head;
+		}
+
+		/* skip iconics */
+		if (winfocus && winfocus->iconic) {
+			TAILQ_FOREACH_REVERSE(winfocus, wl, ws_win_list, entry)
+				if (winfocus->iconic == 0)
+					break;
+		}
 		break;
 
 	case SWM_ARG_ID_FOCUSNEXT:
-		winfocus = TAILQ_NEXT(cur_focus, entry);
-		if (winfocus == NULL)
-			winfocus = TAILQ_FIRST(wl);
+		head = TAILQ_NEXT(cur_focus, entry);
+		if (head == NULL)
+			head = TAILQ_FIRST(wl);
+		winfocus = head;
+
+		/* skip iconics */
+		if (winfocus && winfocus->iconic) {
+			TAILQ_FOREACH(winfocus, wl, entry)
+				if (winfocus->iconic == 0)
+					break;
+		}
 		break;
 
 	case SWM_ARG_ID_FOCUSMAIN:
@@ -1757,11 +2340,10 @@ focus(struct swm_region *r, union arg *args)
 	default:
 		return;
 	}
-
 	if (winfocus == winlostfocus || winfocus == NULL)
 		return;
 
-	focus_magic(winfocus, SWM_F_GENERIC);
+	focus_magic(winfocus);
 }
 
 void
@@ -1780,6 +2362,8 @@ cycle_layout(struct swm_region *r, union arg *args)
 		ws->cur_layout = &layouts[0];
 
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 	a.id = SWM_ARG_ID_FOCUSCUR;
 	focus(r, &a);
 	bar_update();
@@ -1796,7 +2380,7 @@ 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();
 }
 
@@ -1816,17 +2400,38 @@ stack(void) {
 
 			/* start with screen geometry, adjust for bar */
 			g = r->g;
-			g.w -= 2;
-			g.h -= 2;
+			g.w -= 2 * border_width;
+			g.h -= 2 * border_width;
 			if (bar_enabled) {
-				g.y += bar_height;
+				if (!bar_at_bottom)
+					g.y += bar_height;
 				g.h -= bar_height;
 			}
 			r->ws->cur_layout->l_stack(r->ws, &g);
+			/* save r so we can track region changes */
+			r->ws->old_r = r;
 		}
 	}
 	if (font_adjusted)
 		font_adjusted--;
+
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
+}
+
+void
+store_float_geom(struct ws_win *win, struct swm_region *r)
+{
+	/* retain window geom and region geom */
+	win->g_float.x = win->g.x;
+	win->g_float.y = win->g.y;
+	win->g_float.w = win->g.w;
+	win->g_float.h = win->g.h;
+	win->rg_float.x = r->g.x;
+	win->rg_float.y = r->g.y;
+	win->rg_float.w = r->g.w;
+	win->rg_float.h = r->g.h;
+	win->g_floatvalid = 1;
 }
 
 void
@@ -1840,41 +2445,77 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 
 	bzero(&wc, sizeof wc);
 	mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
+
+	/*
+	 * to allow windows to change their size (e.g. mplayer fs) only retrieve
+	 * geom on ws switches or return from max mode
+	 */
+
+	if (win->floatmaxed || (r != r->ws->old_r && win->g_floatvalid
+	    && !(win->ewmh_flags & EWMH_F_FULLSCREEN))) {
+		/*
+		 * use stored g and rg to set relative position and size
+		 * as in old region or before max stack mode
+		 */
+		win->g.x = win->g_float.x - win->rg_float.x + r->g.x;
+		win->g.y = win->g_float.y - win->rg_float.y + r->g.y;
+		win->g.w = win->g_float.w;
+		win->g.h = win->g_float.h;
+		win->g_floatvalid = 0;
+	}
+
+	win->floatmaxed = 0;
+
 	if ((win->quirks & SWM_Q_FULLSCREEN) && (win->g.w >= WIDTH(r)) &&
 	    (win->g.h >= HEIGHT(r)))
 		wc.border_width = 0;
 	else
-		wc.border_width = 1;
+		wc.border_width = border_width;
 	if (win->transient && (win->quirks & SWM_Q_TRANSSZ)) {
 		win->g.w = (double)WIDTH(r) * dialog_ratio;
 		win->g.h = (double)HEIGHT(r) * dialog_ratio;
 	}
-	wc.width = win->g.w;
-	wc.height = win->g.h;
-	if (win->manual) {
-		wc.x = win->g.x;
-		wc.y = win->g.y;
-	} else {
-		wc.x = (WIDTH(r) - win->g.w) / 2;
-		wc.y = (HEIGHT(r) - win->g.h) / 2;
+
+	if (!win->manual) {
+		/*
+		 * 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;
 	}
 
-	/* adjust for region */
-	if (wc.x < r->g.x)
-		wc.x += r->g.x;
-	if (wc.y < r->g.y)
-		wc.y += r->g.y;
+	/* win can be outside r if new r smaller than old r */
+	/* Ensure top left corner inside r (move probs otherwise) */
+	if (win->g.x < r->g.x - wc.border_width)
+		win->g.x = r->g.x - wc.border_width;
+	if (win->g.x > r->g.x + r->g.w - 1)
+		win->g.x = (win->g.w > r->g.w) ? r->g.x :
+		    (r->g.x + r->g.w - win->g.w - 2 * wc.border_width);
+	if (win->g.y < r->g.y - wc.border_width)
+		win->g.y = r->g.y - wc.border_width;
+	if (win->g.y > r->g.y + r->g.h - 1)
+		win->g.y = (win->g.h > r->g.h) ? r->g.y :
+		    (r->g.y + r->g.h - win->g.h - 2 * wc.border_width);
 
-	win->g.x = wc.x;
-	win->g.y = wc.y;
-	win->g.w = wc.width;
-	win->g.h = wc.height;
+	wc.x = win->g.x;
+	wc.y = win->g.y;
+	wc.width = win->g.w;
+	wc.height = win->g.h;
+
+	/*
+	 * Retain floater and transient geometry for correct positioning
+	 * when ws changes region
+	 */
+	if (!(win->ewmh_flags & EWMH_F_FULLSCREEN))
+		store_float_geom(win, r);
 
 	DNPRINTF(SWM_D_MISC, "stack_floater: 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);
-	configreq_win(win);
 }
 
 /*
@@ -1915,8 +2556,9 @@ void
 stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 {
 	XWindowChanges		wc;
+	XWindowAttributes	wa;
 	struct swm_geometry	win_g, r_g = *g;
-	struct ws_win		*win;
+	struct ws_win		*win, *fs_win = 0;
 	int			i, j, s, stacks;
 	int			w_inc = 1, h_inc, w_base = 1, h_base;
 	int			hrh, extra = 0, h_slice, last_h = 0;
@@ -1932,7 +2574,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)
+		if (win->transient == 0 && win->floating == 0
+		    && win->iconic == 0)
 			break;
 
 	if (win == NULL)
@@ -1981,17 +2624,25 @@ 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) + 2) / 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);
-	win_g.h = hrh - 2;
+	win_g.h = hrh - 2 * border_width;
 
 	/*  stack all the tiled windows */
 	i = j = 0, s = stacks;
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
 		if (win->transient != 0 || win->floating != 0)
 			continue;
+		if (win->iconic != 0)
+			continue;
+
+		if (win->ewmh_flags & EWMH_F_FULLSCREEN) {
+			fs_win = win;
+			continue;
+		}
 
 		if (split && i == split) {
 			colno = (winno - mwin) / stacks;
@@ -2003,15 +2654,16 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 			if (flip)
 				win_g.x = r_g.x;
 			else
-				win_g.x += win_g.w + 2;
-			win_g.w = (r_g.w - msize - (stacks * 2)) / stacks;
+				win_g.x += win_g.w + 2 * border_width;
+			win_g.w = (r_g.w - msize -
+			    (stacks * 2 * border_width)) / stacks;
 			if (s == 1)
-				win_g.w += (r_g.w - msize - (stacks * 2)) %
-				    stacks;
+				win_g.w += (r_g.w - msize -
+				    (stacks * 2 * border_width)) % stacks;
 			s--;
 			j = 0;
 		}
-		win_g.h = hrh - 2;
+		win_g.h = hrh - 2 * border_width;
 		if (rot) {
 			h_inc = win->sh.width_inc;
 			h_base = win->sh.base_width;
@@ -2038,10 +2690,15 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 		if (j == 0)
 			win_g.y = r_g.y;
 		else
-			win_g.y += last_h + 2;
+			win_g.y += last_h + 2 * border_width;
 
 		bzero(&wc, sizeof wc);
-		wc.border_width = 1;
+		if (disable_border && bar_enabled == 0 && winno == 1){
+			wc.border_width = 0;
+			win_g.w += 2 * border_width;
+			win_g.h += 2 * border_width;
+		} else
+			wc.border_width = border_width;
 		reconfigure = 0;
 		if (rot) {
 			if (win->g.x != win_g.y || win->g.y != win_g.x ||
@@ -2066,24 +2723,37 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 			adjust_font(win);
 			mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
 			XConfigureWindow(display, win->id, mask, &wc);
-			configreq_win(win);
 		}
-		XMapRaised(display, win->id);
+
+		if (XGetWindowAttributes(display, win->id, &wa))
+			if (wa.map_state == IsUnmapped)
+				XMapRaised(display, win->id);
 
 		last_h = win_g.h;
 		i++;
 		j++;
 	}
 
- notiles:
+notiles:
 	/* now, stack all the floaters and transients */
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
 		if (win->transient == 0 && win->floating == 0)
 			continue;
+		if (win->iconic == 1)
+			continue;
+		if (win->ewmh_flags & EWMH_F_FULLSCREEN) {
+			fs_win = win;
+			continue;
+		}
 
 		stack_floater(win, ws->r);
 		XMapRaised(display, win->id);
 	}
+
+	if (fs_win) {
+		stack_floater(fs_win, ws->r);
+		XMapRaised(display, fs_win->id);
+	}
 }
 
 void
@@ -2175,7 +2845,7 @@ horizontal_config(struct workspace *ws, int id)
 void
 horizontal_stack(struct workspace *ws, struct swm_geometry *g)
 {
-	DNPRINTF(SWM_D_STACK, "vertical_stack: workspace: %d\n", ws->idx);
+	DNPRINTF(SWM_D_STACK, "horizontal_stack: workspace: %d\n", ws->idx);
 
 	stack_master(ws, g, 1, 0);
 }
@@ -2206,18 +2876,32 @@ max_stack(struct workspace *ws, struct swm_geometry *g)
 			continue;
 		}
 
+		if (win->floating && win->floatmaxed == 0 ) {
+			/*
+			 * retain geometry for retrieval on exit from
+			 * max_stack mode
+			 */
+			store_float_geom(win, ws->r);
+			win->floatmaxed = 1;
+		}
+
 		/* only reconfigure if necessary */
 		if (win->g.x != gg.x || win->g.y != gg.y || win->g.w != gg.w ||
 		    win->g.h != gg.h) {
 			bzero(&wc, sizeof wc);
-			wc.border_width = 1;
 			win->g.x = wc.x = gg.x;
 			win->g.y = wc.y = gg.y;
-			win->g.w = wc.width = gg.w;
-			win->g.h = wc.height = gg.h;
+			if (bar_enabled){
+				wc.border_width = border_width;
+				win->g.w = wc.width = gg.w;
+				win->g.h = wc.height = gg.h;
+			} else {
+				wc.border_width = 0;
+				win->g.w = wc.width = gg.w + 2 * border_width;
+				win->g.h = wc.height = gg.h + 2 * border_width;
+			}
 			mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
 			XConfigureWindow(display, win->id, mask, &wc);
-			configreq_win(win);
 		}
 		/* unmap only if we don't have multi screen */
 		if (win != ws->focus)
@@ -2230,7 +2914,7 @@ max_stack(struct workspace *ws, struct swm_geometry *g)
 		if (parent)
 			XMapRaised(display, parent->id);
 		stack_floater(wintrans, ws->r);
-		focus_magic(wintrans, SWM_F_TRANSIENT);
+		focus_magic(wintrans);
 	}
 }
 
@@ -2238,7 +2922,7 @@ void
 send_to_ws(struct swm_region *r, union arg *args)
 {
 	int			wsid = args->id;
-	struct ws_win		*win = win;
+	struct ws_win		*win = NULL, *parent;
 	struct workspace	*ws, *nws;
 	Atom			ws_idx_atom = 0;
 	unsigned char		ws_idx_str[SWM_PROPLEN];
@@ -2260,6 +2944,15 @@ send_to_ws(struct swm_region *r, union arg *args)
 
 	a.id = SWM_ARG_ID_FOCUSPREV;
 	focus(r, &a);
+	if (win->transient) {
+		parent = find_window(win->transient);
+		if (parent) {
+			unmap_window(parent);
+			TAILQ_REMOVE(&ws->winlist, parent, entry);
+			TAILQ_INSERT_TAIL(&nws->winlist, parent, entry);
+			parent->ws = nws;
+		}
+	}
 	unmap_window(win);
 	TAILQ_REMOVE(&ws->winlist, win, entry);
 	TAILQ_INSERT_TAIL(&nws->winlist, win, entry);
@@ -2274,15 +2967,163 @@ send_to_ws(struct swm_region *r, union arg *args)
 		XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
 		    PropModeReplace, ws_idx_str, SWM_PROPLEN);
 	}
+
 	stack();
 }
 
 void
+iconify(struct swm_region *r, union arg *args)
+{
+	union arg a;
+
+	if (r->ws->focus == NULL)
+		return;
+	unmap_window(r->ws->focus);
+	update_iconic(r->ws->focus, 1);
+	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
+	r->ws->focus = NULL;
+	a.id = SWM_ARG_ID_FOCUSCUR;
+	focus(r, &a);
+}
+
+unsigned char *
+get_win_name(Display *dpy, Window win, Atom wname, Atom stype,
+    unsigned long *slen)
+{
+	int			status, retfmt;
+	unsigned long		nitems, nbytes, nextra;
+	unsigned char		*prop = NULL;
+	Atom			rettype;
+
+	status = XGetWindowProperty(dpy, win, wname, 0L, 0L, False, stype,
+	    &rettype, &retfmt,  &nitems, &nbytes, &prop);
+	if (status != Success)
+		return (NULL);
+	XFree(prop);
+
+	status = XGetWindowProperty(dpy, win, wname, 0L, nbytes, False,
+	    stype, &rettype, &retfmt, &nitems, &nextra, &prop);
+	if (status != Success) {
+		XFree(prop);
+		return (NULL);
+	}
+	if (rettype != stype) {
+		XFree(prop);
+		return (NULL);
+	}
+	*slen = nitems;
+	return (prop);
+}
+
+void
+uniconify(struct swm_region *r, union arg *args)
+{
+	struct ws_win		*win;
+	FILE			*lfile;
+	char			*name;
+	int			count = 0;
+	unsigned long		len;
+
+	DNPRINTF(SWM_D_MISC, "uniconify\n");
+
+	if (r && r->ws == NULL)
+		return;
+
+	/* make sure we have anything to uniconify */
+	TAILQ_FOREACH(win, &r->ws->winlist, entry) {
+		if (win->ws == NULL)
+			continue; /* should never happen */
+		if (win->iconic == 0)
+			continue;
+		count++;
+	}
+	if (count == 0)
+		return;
+
+	search_r = r;
+
+	spawn_select(r, args, "uniconify", &searchpid);
+
+	if ((lfile = fdopen(select_list_pipe[1], "w")) == NULL)
+		return;
+
+	TAILQ_FOREACH(win, &r->ws->winlist, entry) {
+		if (win->ws == NULL)
+			continue; /* should never happen */
+		if (win->iconic == 0)
+			continue;
+
+		name = get_win_name(display, win->id, a_wmname, a_string,
+		    &len);
+		if (name == NULL)
+			continue;
+		fprintf(lfile, "%s.%lu\n", name, win->id);
+		XFree(name);
+	}
+
+	fclose(lfile);
+}
+
+#define MAX_RESP_LEN	1024
+
+void
+search_do_resp(void)
+{
+	ssize_t			rbytes;
+	struct ws_win		*win;
+	char			*name, *resp, *s;
+	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");
+		return;
+	}
+
+	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';
+	len = strlen(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);
+		if (name == NULL)
+			continue;
+		if (asprintf(&s, "%s.%lu", name, win->id) == -1) {
+			XFree(name);
+			continue;
+		}
+		XFree(name);
+		if (strncmp(s, resp, len) == 0) {
+			/* XXX this should be a callback to generalize */
+			update_iconic(win, 0);
+			free(s);
+			break;
+		}
+		free(s);
+	}
+done:
+	free(resp);
+}
+
+void
 wkill(struct swm_region *r, union arg *args)
 {
 	DNPRINTF(SWM_D_MISC, "wkill %d\n", args->id);
 
-	if(r->ws->focus == NULL)
+	if (r->ws->focus == NULL)
 		return;
 
 	if (args->id == SWM_ARG_ID_KILLWINDOW)
@@ -2292,20 +3133,66 @@ wkill(struct swm_region *r, union arg *args)
 			client_msg(r->ws->focus, adelete);
 }
 
+
+int
+floating_toggle_win(struct ws_win *win)
+{
+	struct swm_region	*r;
+
+	if (win == NULL)
+		return 0;
+
+	if (!win->ws->r)
+		return 0;
+
+	r = win->ws->r;
+
+	/* reject floating toggles in max stack mode */
+	if (win->ws->cur_layout == &layouts[SWM_MAX_STACK])
+		return 0;
+
+	if (win->floating) {
+		if (!win->floatmaxed) {
+			/* retain position for refloat */
+			store_float_geom(win, r);
+		}
+		win->floating = 0;
+	} else {
+		if (win->g_floatvalid) {
+			/* refloat at last floating relative position */
+			win->g.x = win->g_float.x - win->rg_float.x + r->g.x;
+			win->g.y = win->g_float.y - win->rg_float.y + r->g.y;
+			win->g.w = win->g_float.w;
+			win->g.h = win->g_float.h;
+		}
+		win->floating = 1;
+	}
+
+	ewmh_update_actions(win);
+
+	return 1;
+}
+
 void
 floating_toggle(struct swm_region *r, union arg *args)
 {
-	struct ws_win	*win = r->ws->focus;
-	union arg	a;
+	struct ws_win		*win = r->ws->focus;
+	union arg		a;
 
 	if (win == NULL)
 		return;
 
-	win->floating = !win->floating;
-	win->manual = 0;
+	ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom,
+	    _NET_WM_STATE_TOGGLE);
+
 	stack();
-	a.id = SWM_ARG_ID_FOCUSCUR;
-	focus(win->ws->r, &a);
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
+
+	if (win == win->ws->focus) {
+		a.id = SWM_ARG_ID_FOCUSCUR;
+		focus(win->ws->r, &a);
+	}
 }
 
 void
@@ -2318,12 +3205,12 @@ resize_window(struct ws_win *win, int center)
 	r = root_to_region(win->wa.root);
 	bzero(&wc, sizeof wc);
 	mask = CWBorderWidth | CWWidth | CWHeight;
-	wc.border_width = 1;
+	wc.border_width = border_width;
 	wc.width = win->g.w;
 	wc.height = win->g.h;
 	if (center == SWM_ARG_ID_CENTER) {
-		wc.x = (WIDTH(r) - win->g.w) / 2;
-		wc.y = (HEIGHT(r) - win->g.h) / 2;
+		wc.x = (WIDTH(r) - win->g.w) / 2 - border_width;
+		wc.y = (HEIGHT(r) - win->g.h) / 2 - border_width;
 		mask |= CWX | CWY;
 	}
 
@@ -2331,7 +3218,6 @@ resize_window(struct ws_win *win, int center)
 	    win->id, wc.x, wc.y, wc.width, wc.height);
 
 	XConfigureWindow(display, win->id, mask, &wc);
-	configreq_win(win);
 }
 
 void
@@ -2340,6 +3226,8 @@ resize(struct ws_win *win, union arg *args)
 	XEvent			ev;
 	Time			time = 0;
 	struct swm_region	*r = win->ws->r;
+	int			relx, rely;
+
 
 	DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
@@ -2347,14 +3235,38 @@ resize(struct ws_win *win, union arg *args)
 	if (!(win->transient != 0 || win->floating != 0))
 		return;
 
+	/* reject resizes in max mode for floaters (transient ok) */
+	if (win->floatmaxed)
+		return;
+
+	win->manual = 1;
+	ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom,
+	    _NET_WM_STATE_ADD);
+
+	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
+
 	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
 	    GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
 		return;
-	XWarpPointer(display, None, win->id, 0, 0, 0, 0, win->g.w, win->g.h);
+
+	/* 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;
+
+	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;
+
+	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:
@@ -2362,22 +3274,21 @@ resize(struct ws_win *win, union arg *args)
 			break;
 		case MotionNotify:
 			/* do not allow resize outside of region */
-			if (ev.xmotion.y_root < r->g.y ||
-			    ev.xmotion.y_root >= r->g.y + r->g.h - 1)
-				continue;
-			if (ev.xmotion.x_root < r->g.x ||
-			    ev.xmotion.x_root >= r->g.x + r->g.w - 1)
+			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;
 
 			if (ev.xmotion.x <= 1)
 				ev.xmotion.x = 1;
 			if (ev.xmotion.y <= 1)
 				ev.xmotion.y = 1;
-			win->g.w = ev.xmotion.x;
-			win->g.h = ev.xmotion.y;
+			win->g.w = ev.xmotion.x + 1;
+			win->g.h = ev.xmotion.y + 1;
 
-			/* not free, don't sync more than 60 times / second */
-			if ((ev.xmotion.time - time) > (1000 / 60) ) {
+			/* 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);
@@ -2389,12 +3300,14 @@ resize(struct ws_win *win, union arg *args)
 		XSync(display, False);
 		resize_window(win, args->id);
 	}
+	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);
 
 	/* drain events */
-	while (XCheckMaskEvent(display, EnterWindowMask, &ev));
+	drain_enter_notify();
 }
 
 void
@@ -2409,12 +3322,12 @@ move_window(struct ws_win *win)
 	mask = CWX | CWY;
 	wc.x = win->g.x;
 	wc.y = win->g.y;
+	wc.border_width = border_width;
 
 	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);
 
 	XConfigureWindow(display, win->id, mask, &wc);
-	configreq_win(win);
 }
 
 void
@@ -2422,17 +3335,24 @@ move(struct ws_win *win, union arg *args)
 {
 	XEvent			ev;
 	Time			time = 0;
-	int			restack = 0;
 	struct swm_region	*r = win->ws->r;
 
 	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
 
-	if (win->floating == 0) {
-		win->floating = 1;
-		win->manual = 1;
-		restack = 1;
+	/* in max_stack mode should only move transients */
+	if (win->ws->cur_layout == &layouts[SWM_MAX_STACK] && !win->transient)
+		return;
+
+	win->manual = 1;
+	if (win->floating == 0 && !win->transient) {
+		ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom,
+		    _NET_WM_STATE_ADD);
 	}
+	ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom,
+	    _NET_WM_STATE_ADD);
+
+	stack();
 
 	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
 	    GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
@@ -2441,26 +3361,25 @@ move(struct ws_win *win, union arg *args)
 	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 out of region */
-			if (ev.xmotion.y_root < r->g.y ||
-			    ev.xmotion.y_root + win->g.h >= r->g.y + r->g.h - 1)
-				continue;
-			if (ev.xmotion.x_root < r->g.x ||
-			    ev.xmotion.x_root + win->g.w >= r->g.x + r->g.w - 1)
+			/* 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;
-			win->g.y = ev.xmotion.y_root;
+			win->g.x = ev.xmotion.x_root - border_width;
+			win->g.y = ev.xmotion.y_root - border_width;
 
-			/* not free, don't sync more than 60 times / second */
-			if ((ev.xmotion.time - time) > (1000 / 60) ) {
+			/* 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);
@@ -2472,15 +3391,75 @@ move(struct ws_win *win, union arg *args)
 		XSync(display, False);
 		move_window(win);
 	}
+	store_float_geom(win,r);
 	XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0);
 	XUngrabPointer(display, CurrentTime);
-	if (restack)
-		stack();
 
 	/* drain events */
-	while (XCheckMaskEvent(display, EnterWindowMask, &ev));
+	drain_enter_notify();
 }
 
+/* user/key callable function IDs */
+enum keyfuncid {
+	kf_cycle_layout,
+	kf_stack_reset,
+	kf_master_shrink,
+	kf_master_grow,
+	kf_master_add,
+	kf_master_del,
+	kf_stack_inc,
+	kf_stack_dec,
+	kf_swap_main,
+	kf_focus_next,
+	kf_focus_prev,
+	kf_swap_next,
+	kf_swap_prev,
+	kf_spawn_term,
+	kf_spawn_menu,
+	kf_quit,
+	kf_restart,
+	kf_focus_main,
+	kf_ws_1,
+	kf_ws_2,
+	kf_ws_3,
+	kf_ws_4,
+	kf_ws_5,
+	kf_ws_6,
+	kf_ws_7,
+	kf_ws_8,
+	kf_ws_9,
+	kf_ws_10,
+	kf_ws_next,
+	kf_ws_prev,
+	kf_ws_prior,
+	kf_screen_next,
+	kf_screen_prev,
+	kf_mvws_1,
+	kf_mvws_2,
+	kf_mvws_3,
+	kf_mvws_4,
+	kf_mvws_5,
+	kf_mvws_6,
+	kf_mvws_7,
+	kf_mvws_8,
+	kf_mvws_9,
+	kf_mvws_10,
+	kf_bar_toggle,
+	kf_wind_kill,
+	kf_wind_del,
+	kf_screenshot_all,
+	kf_screenshot_wind,
+	kf_float_toggle,
+	kf_version,
+	kf_spawn_lock,
+	kf_spawn_initscr,
+	kf_spawn_custom,
+	kf_iconify,
+	kf_uniconify,
+	kf_dumpwins, /* MUST BE LAST */
+	kf_invalid
+};
+
 /* key definitions */
 void
 dummykeyfunc(struct swm_region *r, union arg *args)
@@ -2528,6 +3507,7 @@ 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_prior",		priorws,	{0} },
 	{ "screen_next",	cyclescr,	{.id = SWM_ARG_ID_CYCLESC_UP} },
 	{ "screen_prev",	cyclescr,	{.id = SWM_ARG_ID_CYCLESC_DOWN} },
 	{ "mvws_1",		send_to_ws,	{.id = 0} },
@@ -2550,7 +3530,9 @@ struct keyfunc {
 	{ "spawn_lock",		legacyfunc,	{0} },
 	{ "spawn_initscr",	legacyfunc,	{0} },
 	{ "spawn_custom",	dummykeyfunc,	{0} },
-	{ "dumpwins",		dumpwins,	{0} },
+	{ "iconify",		iconify,	{0} },
+	{ "uniconify",		uniconify,	{0} },
+	{ "dumpwins",		dumpwins,	{0} }, /* MUST BE LAST */
 	{ "invalid key func",	NULL,		{0} },
 };
 struct key {
@@ -2606,15 +3588,15 @@ struct spawn_prog {
 int				spawns_size = 0, spawns_length = 0;
 struct spawn_prog		*spawns = NULL;
 
-void
-spawn_custom(struct swm_region *r, union arg *args, char *spawn_name)
+int
+spawn_expand(struct swm_region *r, union arg *args, char *spawn_name,
+    char ***ret_args)
 {
-	union arg		a;
 	struct spawn_prog	*prog = NULL;
 	int			i;
 	char			*ap, **real_args;
 
-	DNPRINTF(SWM_D_SPAWN, "spawn_custom %s\n", spawn_name);
+	DNPRINTF(SWM_D_SPAWN, "spawn_expand %s\n", spawn_name);
 
 	/* find program */
 	for (i = 0; i < spawns_length; i++) {
@@ -2624,7 +3606,7 @@ spawn_custom(struct swm_region *r, union arg *args, char *spawn_name)
 	if (prog == NULL) {
 		fprintf(stderr, "spawn_custom: program %s not found\n",
 		    spawn_name);
-		return;
+		return (-1);
 	}
 
 	/* make room for expanded args */
@@ -2681,10 +3663,66 @@ spawn_custom(struct swm_region *r, union arg *args, char *spawn_name)
 		fprintf(stderr, "\n");
 	}
 #endif
+	*ret_args = real_args;
+	return (prog->argc);
+}
+
+void
+spawn_custom(struct swm_region *r, union arg *args, char *spawn_name)
+{
+	union arg		a;
+	char			**real_args;
+	int			spawn_argc, i;
+
+	if ((spawn_argc = spawn_expand(r, args, spawn_name, &real_args)) < 0)
+		return;
+	a.argv = real_args;
+	if (fork() == 0)
+		spawn(r, &a, 1);
+
+	for (i = 0; i < spawn_argc; i++)
+		free(real_args[i]);
+	free(real_args);
+}
 
+void
+spawn_select(struct swm_region *r, union arg *args, char *spawn_name, int *pid)
+{
+	union arg		a;
+	char			**real_args;
+	int			i, spawn_argc;
+
+	if ((spawn_argc = spawn_expand(r, args, spawn_name, &real_args)) < 0)
+		return;
 	a.argv = real_args;
-	spawn(r, &a);
-	for (i = 0; i < prog->argc; i++)
+
+	if (pipe(select_list_pipe) == -1)
+		err(1, "pipe error");
+	if (pipe(select_resp_pipe) == -1)
+		err(1, "pipe error");
+
+	if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
+		err(1, "could not disable SIGPIPE");
+	switch (*pid = fork()) {
+	case -1:
+		err(1, "cannot fork");
+		break;
+	case 0: /* child */
+		if (dup2(select_list_pipe[0], 0) == -1)
+			errx(1, "dup2");
+		if (dup2(select_resp_pipe[1], 1) == -1)
+			errx(1, "dup2");
+		close(select_list_pipe[1]);
+		close(select_resp_pipe[0]);
+		spawn(r, &a, 0);
+		break;
+	default: /* parent */
+		close(select_list_pipe[0]);
+		close(select_resp_pipe[1]);
+		break;
+	}
+
+	for (i = 0; i < spawn_argc; i++)
 		free(real_args[i]);
 	free(real_args);
 }
@@ -2797,8 +3835,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");
 		}
@@ -2825,6 +3864,13 @@ setup_spawn(void)
 					" -nf $bar_font_color"
 					" -sb $bar_border"
 					" -sf $bar_color",	0);
+	setconfspawn("uniconify",	"dmenu"
+					" -i"
+					" -fn $bar_font"
+					" -nb $bar_color"
+					" -nf $bar_font_color"
+					" -sb $bar_border"
+					" -sf $bar_color",	0);
 }
 
 /* key bindings */
@@ -2890,7 +3936,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",
@@ -2937,7 +3984,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);
@@ -2946,7 +3993,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);
@@ -2962,7 +4009,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);
 		}
@@ -3050,6 +4097,7 @@ 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_a,		kf_ws_prior,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_Right,	kf_screen_next,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_Left,	kf_screen_prev,	NULL);
 	setkeybinding(MODKEY|ShiftMask,	XK_1,		kf_mvws_1,	NULL);
@@ -3073,6 +4121,8 @@ setup_keys(void)
 	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,		XK_w,		kf_iconify,	NULL);
+	setkeybinding(MODKEY|ShiftMask,	XK_w,		kf_uniconify,	NULL);
 #ifdef SWM_DEBUG
 	setkeybinding(MODKEY|ShiftMask,	XK_d,		kf_dumpwins,	NULL);
 #endif
@@ -3090,7 +4140,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);
@@ -3131,7 +4181,7 @@ grabbuttons(struct ws_win *win, int focused)
 
 	updatenumlockmask();
 	XUngrabButton(display, AnyButton, AnyModifier, win->id);
-	if(focused) {
+	if (focused) {
 		for (i = 0; i < LENGTH(buttons); i++)
 			if (buttons[i].action == client_click)
 				for (j = 0; j < LENGTH(modifiers); j++)
@@ -3152,6 +4202,7 @@ const char *quirkname[] = {
 	"ANYWHERE",
 	"XTERM_FONTADJ",
 	"FULLSCREEN",
+	"FOCUSPREV",
 };
 
 /* SWM_Q_WS: retain '|' for back compat for now (2009-08-11) */
@@ -3172,7 +4223,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);
@@ -3235,7 +4287,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);
@@ -3243,8 +4295,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);
@@ -3258,7 +4311,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);
 		}
@@ -3286,9 +4339,8 @@ setconfquirk(char *selector, char *value, int flags)
 void
 setup_quirks(void)
 {
-	setquirk("MPlayer",		"xv",		SWM_Q_FLOAT | SWM_Q_FULLSCREEN);
-	setquirk("OpenOffice.org 2.4",	"VCLSalFrame",	SWM_Q_FLOAT);
-	setquirk("OpenOffice.org 3.0",	"VCLSalFrame",	SWM_Q_FLOAT);
+	setquirk("MPlayer",		"xv",		SWM_Q_FLOAT | SWM_Q_FULLSCREEN | SWM_Q_FOCUSPREV);
+	setquirk("OpenOffice.org 3.2",	"VCLSalFrame",	SWM_Q_FLOAT);
 	setquirk("Firefox-bin",		"firefox-bin",	SWM_Q_TRANSSZ);
 	setquirk("Firefox",		"Dialog",	SWM_Q_FLOAT);
 	setquirk("Gimp",		"gimp",		SWM_Q_FLOAT | SWM_Q_ANYWHERE);
@@ -3299,16 +4351,21 @@ setup_quirks(void)
 	setquirk("Xitk",		"Xine Window",	SWM_Q_FLOAT | SWM_Q_ANYWHERE);
 	setquirk("xine",		"xine Video Fullscreen Window",	SWM_Q_FULLSCREEN | SWM_Q_FLOAT);
 	setquirk("pcb",			"pcb",		SWM_Q_FLOAT);
+	setquirk("SDL_App",		"SDL_App",	SWM_Q_FLOAT | SWM_Q_FULLSCREEN);
 }
 
 /* conf file stuff */
 #define SWM_CONF_FILE	"scrotwm.conf"
 
-enum	{ SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_STACK_ENABLED,
-	  SWM_S_CLOCK_ENABLED, 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_BAR_FONT, SWM_S_BAR_ACTION,
-	  SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO };
+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
+	};
 
 int
 setconfvalue(char *selector, char *value, int flags)
@@ -3320,12 +4377,25 @@ setconfvalue(char *selector, char *value, int flags)
 	case SWM_S_BAR_ENABLED:
 		bar_enabled = atoi(value);
 		break;
+	case SWM_S_BAR_BORDER_WIDTH:
+		bar_border_width = atoi(value);
+		break;
+	case SWM_S_BAR_AT_BOTTOM:
+		bar_at_bottom = atoi(value);
+		break;
 	case SWM_S_STACK_ENABLED:
 		stack_enabled = atoi(value);
 		break;
 	case SWM_S_CLOCK_ENABLED:
 		clock_enabled = atoi(value);
 		break;
+	case SWM_S_CLOCK_FORMAT:
+#ifndef SWM_DENY_CLOCK_FORMAT
+		free(clock_format);
+		if ((clock_format = strdup(value)) == NULL)
+			err(1, "setconfvalue: clock_format");
+#endif
+		break;
 	case SWM_S_CYCLE_EMPTY:
 		cycle_empty = atoi(value);
 		break;
@@ -3341,9 +4411,28 @@ setconfvalue(char *selector, char *value, int flags)
 	case SWM_S_TITLE_CLASS_ENABLED:
 		title_class_enabled = atoi(value);
 		break;
+	case SWM_S_WINDOW_NAME_ENABLED:
+		window_name_enabled = atoi(value);
+		break;
 	case SWM_S_TITLE_NAME_ENABLED:
 		title_name_enabled = atoi(value);
 		break;
+	case SWM_S_FOCUS_MODE:
+		if (!strcmp(value, "default"))
+			focus_mode = SWM_FOCUS_DEFAULT;
+		else if (!strcmp(value, "follow_cursor"))
+			focus_mode = SWM_FOCUS_FOLLOW;
+		else if (!strcmp(value, "synergy"))
+			focus_mode = SWM_FOCUS_SYNERGY;
+		else
+			err(1, "focus_mode");
+		break;
+	case SWM_S_DISABLE_BORDER:
+		disable_border = atoi(value);
+		break;
+	case SWM_S_BORDER_WIDTH:
+		border_width = atoi(value);
+		break;
 	case SWM_S_BAR_FONT:
 		free(bar_fonts[0]);
 		if ((bar_fonts[0] = strdup(value)) == NULL)
@@ -3410,7 +4499,9 @@ struct config_option {
 };
 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_color",			setconfcolor,	SWM_S_COLOR_BAR },
 	{ "bar_font_color",		setconfcolor,	SWM_S_COLOR_BAR_FONT },
 	{ "bar_font",			setconfvalue,	SWM_S_BAR_FONT },
@@ -3419,6 +4510,7 @@ struct config_option configopt[] = {
 	{ "bind",			setconfbinding,	0 },
 	{ "stack_enabled",		setconfvalue,	SWM_S_STACK_ENABLED },
 	{ "clock_enabled",		setconfvalue,	SWM_S_CLOCK_ENABLED },
+	{ "clock_format",		setconfvalue,	SWM_S_CLOCK_FORMAT },
 	{ "color_focus",		setconfcolor,	SWM_S_COLOR_FOCUS },
 	{ "color_unfocus",		setconfcolor,	SWM_S_COLOR_UNFOCUS },
 	{ "cycle_empty",		setconfvalue,	SWM_S_CYCLE_EMPTY },
@@ -3431,9 +4523,13 @@ struct config_option configopt[] = {
 	{ "spawn_term",			setconfvalue,	SWM_S_SPAWN_TERM },
 	{ "screenshot_enabled",		setconfvalue,	SWM_S_SS_ENABLED },
 	{ "screenshot_app",		setconfvalue,	SWM_S_SS_APP },
+	{ "window_name_enabled",	setconfvalue,	SWM_S_WINDOW_NAME_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 }
+	{ "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 },
 };
 
 
@@ -3534,13 +4630,52 @@ conf_load(char *filename)
 }
 
 void
-set_child_transient(struct ws_win *win)
+set_child_transient(struct ws_win *win, Window *trans)
 {
-	struct ws_win		*parent;
+	struct ws_win		*parent, *w;
+	XWMHints		*wmh = NULL;
+	struct swm_region	*r;
+	struct workspace	*ws;
 
 	parent = find_window(win->transient);
 	if (parent)
 		parent->child_trans = win;
+	else {
+		DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist"
+		    " for %lu trans %lu\n", win->id, win->transient);
+
+		if (win->hints == NULL) {
+			fprintf(stderr, "no hints for %lu\n", win->id);
+			return;
+		}
+
+		r = root_to_region(win->wa.root);
+		ws = r->ws;
+		/* parent doen't exist in our window list */
+		TAILQ_FOREACH(w, &ws->winlist, entry) {
+			if (wmh)
+				XFree(wmh);
+
+			if ((wmh = XGetWMHints(display, w->id)) == NULL) {
+				fprintf(stderr, "can't get hints for %lu\n",
+				    w->id);
+				continue;
+			}
+
+			if (win->hints->window_group != wmh->window_group)
+				continue;
+
+			w->child_trans = win;
+			win->transient = w->id;
+			*trans = w->id;
+			DNPRINTF(SWM_D_MISC, "set_child_transient: asjusting "
+			    "transient to %lu\n", win->transient);
+			break;
+		}
+	}
+
+	if (wmh)
+		XFree(wmh);
 }
 
 struct ws_win *
@@ -3567,15 +4702,21 @@ manage_window(Window id)
 		DNPRINTF(SWM_D_MISC, "manage previously unmanaged window "
 		    "%lu\n", win->id);
 		TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
-		TAILQ_INSERT_TAIL(&win->ws->winlist, win, entry);
-		if (win->transient)
-			set_child_transient(win);
+		if (win->transient) {
+			set_child_transient(win, &trans);
+		} if (trans && (ww = find_window(trans)))
+			TAILQ_INSERT_AFTER(&win->ws->winlist, ww, win, entry);
+		else
+			TAILQ_INSERT_TAIL(&win->ws->winlist, win, entry);
+		ewmh_update_actions(win);
 		return (win);
 	}
 
 	if ((win = calloc(1, sizeof(struct ws_win))) == NULL)
 		errx(1, "calloc: failed to allocate memory for new window");
 
+	win->id = id;
+
 	/* Get all the window data in one shot */
 	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
 	if (ws_idx_atom)
@@ -3583,13 +4724,15 @@ manage_window(Window id)
 		    False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
 	XGetWindowAttributes(display, id, &win->wa);
 	XGetWMNormalHints(display, id, &win->sh, &mask);
+	win->hints = XGetWMHints(display, id);
 	XGetTransientForHint(display, id, &trans);
 	if (trans) {
 		win->transient = trans;
-		set_child_transient(win);
+		set_child_transient(win, &trans);
 		DNPRINTF(SWM_D_MISC, "manage_window: win %lu transient %lu\n",
 		    win->id, win->transient);
 	}
+
 	/* get supported protocols */
 	if (XGetWMProtocols(display, id, &prot, &n)) {
 		for (i = 0, pp = prot; i < n; i++, pp++) {
@@ -3602,6 +4745,8 @@ manage_window(Window id)
 			XFree(prot);
 	}
 
+	win->iconic = get_iconic(win);
+
 	/*
 	 * Figure out where to put the window. If it was previously assigned to
 	 * a workspace (either by spawn() or manually moving), and isn't
@@ -3636,12 +4781,18 @@ manage_window(Window id)
 	win->id = id;
 	win->ws = ws;
 	win->s = r->s;	/* this never changes */
-	TAILQ_INSERT_TAIL(&ws->winlist, win, entry);
+	if (trans && (ww = find_window(trans)))
+		TAILQ_INSERT_AFTER(&ws->winlist, ww, win, entry);
+	else
+		TAILQ_INSERT_TAIL(&ws->winlist, win, entry);
 
 	win->g.w = win->wa.width;
 	win->g.h = win->wa.height;
 	win->g.x = win->wa.x;
 	win->g.y = win->wa.y;
+	win->g_floatvalid = 0;
+	win->floatmaxed = 0;
+	win->ewmh_flags = 0;
 
 	/* Set window properties so we can remember this after reincarnation */
 	if (ws_idx_atom && prop == NULL &&
@@ -3651,7 +4802,10 @@ manage_window(Window id)
 		XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
 		    PropModeReplace, ws_idx_str, SWM_PROPLEN);
 	}
-	XFree(prop);
+	if (prop)
+		XFree(prop);
+
+	ewmh_autoquirk(win);
 
 	if (XGetClassHint(display, win->id, &win->ch)) {
 		DNPRINTF(SWM_D_CLASS, "class: %s name: %s\n",
@@ -3682,7 +4836,7 @@ manage_window(Window id)
 		win->manual = 1; /* don't center the quirky windows */
 		bzero(&wc, sizeof wc);
 		mask = 0;
-		if (win->g.y < bar_height) {
+		if (bar_enabled && win->g.y < bar_height) {
 			win->g.y = wc.y = bar_height;
 			mask |= CWY;
 		}
@@ -3701,20 +4855,21 @@ manage_window(Window id)
 			fake_keypress(win, XK_KP_Add, ShiftMask);
 	}
 
+	ewmh_get_win_state(win);
+	ewmh_update_actions(win);
+	ewmh_update_win_state(win, None, _NET_WM_STATE_REMOVE);
+
 	/* border me */
 	if (border_me) {
 		bzero(&wc, sizeof wc);
-		wc.border_width = 1;
+		wc.border_width = border_width;
 		mask = CWBorderWidth;
 		XConfigureWindow(display, win->id, mask, &wc);
-		configreq_win(win);
 	}
 
 	XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
 	    PropertyChangeMask | StructureNotifyMask);
 
-	set_win_state(win, NormalState);
-
 	/* floaters need to be mapped if they are in the current workspace */
 	if ((win->floating || win->transient) && (ws->idx == r->ws->idx))
 		XMapRaised(display, win->id);
@@ -3764,7 +4919,11 @@ unmanage_window(struct ws_win *win)
 			parent->child_trans = NULL;
 	}
 
+	/* focus on root just in case */
+	XSetInputFocus(display, PointerRoot, PointerRoot, CurrentTime);
+
 	focus_prev(win);
+
 	TAILQ_REMOVE(&win->ws->winlist, win, entry);
 	TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
 
@@ -3772,23 +4931,31 @@ unmanage_window(struct ws_win *win)
 }
 
 void
-focus_magic(struct ws_win *win, int do_trans)
+focus_magic(struct ws_win *win)
 {
-	DNPRINTF(SWM_D_FOCUS, "focus_magic: %lu %d\n", WINID(win), do_trans);
+	DNPRINTF(SWM_D_FOCUS, "focus_magic: %lu\n", WINID(win));
 
 	if (win == NULL)
 		return;
 
-	if (do_trans == SWM_F_TRANSIENT && win->child_trans) {
+	if (win->child_trans) {
 		/* win = parent & has a transient so focus on that */
 		if (win->java) {
 			focus_win(win->child_trans);
 			if (win->child_trans->take_focus)
 				client_msg(win, takefocus);
 		} else {
-			focus_win(win->child_trans);
-			if (win->child_trans->take_focus)
-				client_msg(win->child_trans, takefocus);
+			/* make sure transient hasn't dissapeared */
+			if (validate_win(win->child_trans) == 0) {
+				focus_win(win->child_trans);
+				if (win->child_trans->take_focus)
+					client_msg(win->child_trans, takefocus);
+			} else {
+				win->child_trans = NULL;
+				focus_win(win);
+				if (win->take_focus)
+					client_msg(win, takefocus);
+			}
 		}
 	} else {
 		/* regular focus */
@@ -3816,8 +4983,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),
@@ -3845,7 +5012,7 @@ buttonpress(XEvent *e)
 	if ((win = find_window(ev->window)) == NULL)
 		return;
 
-	focus_magic(win, SWM_F_TRANSIENT);
+	focus_magic(win);
 	action = client_click;
 
 	for (i = 0; i < LENGTH(buttons); i++)
@@ -3882,17 +5049,7 @@ configurerequest(XEvent *e)
 	} else {
 		DNPRINTF(SWM_D_EVENT, "configurerequest: change window: %lu\n",
 		    ev->window);
-		if (win->floating) {
-			if (ev->value_mask & CWX)
-				win->g.x = ev->x;
-			if (ev->value_mask & CWY)
-				win->g.y = ev->y;
-			if (ev->value_mask & CWWidth)
-				win->g.w = ev->width;
-			if (ev->value_mask & CWHeight)
-				win->g.h = ev->height;
-		}
-		config_win(win);
+		config_win(win, ev);
 	}
 }
 
@@ -3911,6 +5068,8 @@ configurenotify(XEvent *e)
 		adjust_font(win);
 		if (font_adjusted)
 			stack();
+		if (focus_mode == SWM_FOCUS_DEFAULT)
+			drain_enter_notify();
 	}
 }
 
@@ -3929,8 +5088,13 @@ destroynotify(XEvent *e)
 		return;
 	}
 
+	/* make sure we focus on something */
+	win->floating = 0;
+
 	unmanage_window(win);
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 	free_window(win);
 }
 
@@ -3940,12 +5104,23 @@ enternotify(XEvent *e)
 	XCrossingEvent		*ev = &e->xcrossing;
 	XEvent			cne;
 	struct ws_win		*win;
-
+#if 0
+	struct ws_win		*w;
+	Window			focus_return;
+	int			revert_to_return;
+#endif
 	DNPRINTF(SWM_D_FOCUS, "enternotify: window: %lu mode %d detail %d root "
 	    "%lu subwindow %lu same_screen %d focus %d state %d\n",
 	    ev->window, ev->mode, ev->detail, ev->root, ev->subwindow,
 	    ev->same_screen, ev->focus, ev->state);
 
+	switch (focus_mode) {
+	case SWM_FOCUS_DEFAULT:
+		break;
+	case SWM_FOCUS_FOLLOW:
+		break;
+	case SWM_FOCUS_SYNERGY:
+#if 0
 	/*
 	 * all these checks need to be in this order because the
 	 * XCheckTypedWindowEvent relies on weeding out the previous events
@@ -4005,10 +5180,6 @@ enternotify(XEvent *e)
 	 */
 	if (win->ws->cur_layout->flags & SWM_L_FOCUSPREV &&
 	    last_focus_event != FocusOut) {
-		struct ws_win	*w;
-		Window		focus_return;
-		int		revert_to_return;
-
 		XGetInputFocus(display, &focus_return, &revert_to_return);
 		if ((w = find_window(focus_return)) == NULL ||
 		    w->ws == win->ws) {
@@ -4016,8 +5187,26 @@ enternotify(XEvent *e)
 			return;
 		}
 	}
+#endif
+		break;
+	}
+
+	if ((win = find_window(ev->window)) == NULL) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win == NULL\n");
+		return;
+	}
+
+	/*
+	 * if we have more enternotifies let them handle it in due time
+	 */
+	if (XCheckTypedEvent(display, EnterNotify, &cne) == True) {
+		DNPRINTF(SWM_D_EVENT,
+		    "ignoring enternotify: got more enternotify\n");
+		XPutBackEvent(display, &cne);
+		return;
+	}
 
-	focus_magic(win, SWM_F_TRANSIENT);
+	focus_magic(win);
 }
 
 /* lets us use one switch statement for arbitrary mode/detail combinations */
@@ -4026,6 +5215,7 @@ enternotify(XEvent *e)
 void
 focusevent(XEvent *e)
 {
+#if 0
 	struct ws_win		*win;
 	u_int32_t		mode_detail;
 	XFocusChangeEvent	*ev = &e->xfocus;
@@ -4034,6 +5224,11 @@ focusevent(XEvent *e)
 	    ev->type == FocusIn ? "entering" : "leaving",
 	    ev->window, ev->mode, ev->detail);
 
+	if (last_focus_event == ev->type) {
+		DNPRINTF(SWM_D_FOCUS, "ignoring focusevent: bad ordering\n");
+		return;
+	}
+
 	last_focus_event = ev->type;
 	mode_detail = MERGE_MEMBERS(ev->mode, ev->detail);
 
@@ -4054,9 +5249,11 @@ focusevent(XEvent *e)
 			    SWM_S_COLOR_FOCUS : SWM_S_COLOR_UNFOCUS].color);
 		break;
 	default:
+		fprintf(stderr, "ignoring focusevent\n");
 		DNPRINTF(SWM_D_FOCUS, "ignoring focusevent\n");
 		break;
 	}
+#endif
 }
 
 void
@@ -4107,7 +5304,7 @@ maprequest(XEvent *e)
 	/* make new win focused */
 	r = root_to_region(win->wa.root);
 	if (win->ws == r->ws)
-		focus_magic(win, SWM_F_GENERIC);
+		focus_magic(win);
 }
 
 void
@@ -4119,12 +5316,18 @@ propertynotify(XEvent *e)
 	DNPRINTF(SWM_D_EVENT, "propertynotify: window: %lu\n",
 	    ev->window);
 
-	if (ev->state == PropertyDelete)
-		return; /* ignore */
 	win = find_window(ev->window);
 	if (win == NULL)
 		return;
 
+	if (ev->state == PropertyDelete && ev->atom == a_swm_iconic) {
+		update_iconic(win, 0);
+		XMapRaised(display, win->id);
+		stack();
+		focus_win(win);
+		return;
+	}
+
 	switch (ev->atom) {
 	case XA_WM_NORMAL_HINTS:
 #if 0
@@ -4139,6 +5342,8 @@ propertynotify(XEvent *e)
 		XMoveResizeWindow(display, win->id,
 		    win->g.x, win->g.y, win->g.w, win->g.h);
 #endif
+		if (window_name_enabled)
+			bar_update();
 		break;
 	default:
 		break;
@@ -4157,17 +5362,28 @@ unmapnotify(XEvent *e)
 	if (win == NULL)
 		return;
 
-	/*
-	 * XXX this is a work around for going fullscreen on mplayer
-	 * remove this and find a better heuristic
-	 */
-	if (win->floating)
-		return;
-
 	if (getstate(e->xunmap.window) == NormalState) {
 		unmanage_window(win);
 		stack();
+
+		/* giant hack for apps that don't destroy transient windows */
+		/* eat a bunch of events to prevent remanaging the window */
+		XEvent			cne;
+		while (XCheckWindowEvent(display, e->xunmap.window,
+		    EnterWindowMask, &cne))
+			;
+		while (XCheckWindowEvent(display, e->xunmap.window,
+		    StructureNotifyMask, &cne))
+			;
+		while (XCheckWindowEvent(display, e->xunmap.window,
+		    SubstructureNotifyMask, &cne))
+			;
+		/* resend unmap because we ated it */
+		XUnmapWindow(display, e->xunmap.window);
 	}
+
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
@@ -4185,6 +5401,61 @@ visibilitynotify(XEvent *e)
 					bar_update();
 }
 
+void
+clientmessage(XEvent *e)
+{
+	XClientMessageEvent *ev;
+	struct ws_win *win;
+
+	ev = &e->xclient;
+
+	win = find_window(ev->window);
+	if (win == NULL)
+		return;
+
+	DNPRINTF(SWM_D_EVENT, "clientmessage: window: 0x%lx type: %ld \n",
+	    ev->window, ev->message_type);
+
+	if (ev->message_type == ewmh[_NET_ACTIVE_WINDOW].atom) {
+		DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_ACTIVE_WINDOW \n");
+		focus_win(win);
+	}
+	if (ev->message_type == ewmh[_NET_CLOSE_WINDOW].atom) {
+		DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_CLOSE_WINDOW \n");
+		if (win->can_delete)
+			client_msg(win, adelete);
+		else
+			XKillClient(display, win->id);
+	}
+	if (ev->message_type == ewmh[_NET_MOVERESIZE_WINDOW].atom) {
+		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];
+			if (ev->data.l[0] & (1<<9)) /* y */
+				win->g.y = ev->data.l[2];
+			if (ev->data.l[0] & (1<<10)) /* width */
+				win->g.w = ev->data.l[3];
+			if (ev->data.l[0] & (1<<11)) /* height */
+				win->g.h = ev->data.l[4];
+		}
+		else {
+			/* TODO: Change stack sizes */
+		}
+		config_win(win, NULL);
+	}
+	if (ev->message_type == ewmh[_NET_WM_STATE].atom) {
+		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]);
+
+		stack();
+	}
+}
+
 int
 xerror_start(Display *d, XErrorEvent *ee)
 {
@@ -4236,6 +5507,9 @@ new_region(struct swm_screen *s, int x, int y, int w, int h)
 		    (X(r) + WIDTH(r)) > x &&
 		    Y(r) < (y + h) &&
 		    (Y(r) + HEIGHT(r)) > y) {
+			if (r->ws->r != NULL)
+				r->ws->old_r = r->ws->r;
+			r->ws->r = NULL;
 			XDestroyWindow(display, r->bar_window);
 			TAILQ_REMOVE(&s->rl, r, entry);
 			TAILQ_INSERT_TAIL(&s->orl, r, entry);
@@ -4282,7 +5556,9 @@ new_region(struct swm_screen *s, int x, int y, int w, int h)
 	HEIGHT(r) = h;
 	r->s = s;
 	r->ws = ws;
+	r->ws_prior = NULL;
 	ws->r = r;
+	outputs++;
 	TAILQ_INSERT_TAIL(&s->rl, r, entry);
 }
 
@@ -4308,10 +5584,10 @@ scan_xrandr(int i)
 		TAILQ_REMOVE(&screens[i].rl, r, entry);
 		TAILQ_INSERT_TAIL(&screens[i].orl, r, entry);
 	}
+	outputs = 0;
 
 	/* map virtual screens onto physical screens */
 #ifdef SWM_XRR_HAS_CRTC
-	outputs = 0;
 	if (xrandr_support) {
 		sr = XRRGetScreenResources(display, screens[i].root);
 		if (sr == NULL)
@@ -4325,7 +5601,6 @@ scan_xrandr(int i)
 			ci = XRRGetCrtcInfo(display, sr, sr->crtcs[c]);
 			if (ci->noutput == 0)
 				continue;
-			outputs++;
 
 			if (ci != NULL && ci->mode == None)
 				new_region(&screens[i], 0, 0,
@@ -4372,19 +5647,62 @@ screenchange(XEvent *e) {
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
 			bar_setup(r);
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
-setup_screens(void)
+grab_windows(void)
 {
 	Window			d1, d2, *wins = NULL;
 	XWindowAttributes	wa;
 	unsigned int		no;
-        int			i, j, k;
+	int			i, j;
+	long			state, manage;
+
+	for (i = 0; i < ScreenCount(display); i++) {
+		if (!XQueryTree(display, screens[i].root, &d1, &d2, &wins, &no))
+			continue;
+
+		/* attach windows to a region */
+		/* normal windows */
+		for (j = 0; j < no; j++) {
+			if (!XGetWindowAttributes(display, wins[j], &wa) ||
+			    wa.override_redirect ||
+			    XGetTransientForHint(display, wins[j], &d1))
+				continue;
+
+			state = getstate(wins[j]);
+			manage = state == IconicState;
+			if (wa.map_state == IsViewable || manage)
+				manage_window(wins[j]);
+		}
+		/* transient windows */
+		for (j = 0; j < no; j++) {
+			if (!XGetWindowAttributes(display, wins[j], &wa) ||
+			    wa.override_redirect)
+				continue;
+
+			state = getstate(wins[j]);
+			manage = state == IconicState;
+			if (XGetTransientForHint(display, wins[j], &d1) &&
+			    manage)
+				manage_window(wins[j]);
+		}
+		if (wins) {
+			XFree(wins);
+			wins = NULL;
+		}
+	}
+}
+
+void
+setup_screens(void)
+{
+	int			i, j, k;
 	int			errorbase, major, minor;
 	struct workspace	*ws;
 	int			ws_idx_atom;
-	long			state, manage;
 
 	if ((screens = calloc(ScreenCount(display),
 	     sizeof(struct swm_screen))) == NULL)
@@ -4414,6 +5732,10 @@ setup_screens(void)
 		setscreencolor("black", i + 1, SWM_S_COLOR_BAR);
 		setscreencolor("rgb:a0/a0/a0", i + 1, SWM_S_COLOR_BAR_FONT);
 
+		/* set default cursor */
+		XDefineCursor(display, screens[i].root,
+		    XCreateFontCursor(display, XC_left_ptr));
+
 		/* init all workspaces */
 		/* XXX these should be dynamically allocated too */
 		for (j = 0; j < SWM_WS_MAX; j++) {
@@ -4431,45 +5753,12 @@ setup_screens(void)
 					    SWM_ARG_ID_STACKINIT);
 			ws->cur_layout = &layouts[0];
 		}
-		/* grab existing windows (before we build the bars)*/
-		if (!XQueryTree(display, screens[i].root, &d1, &d2, &wins, &no))
-			continue;
 
 		scan_xrandr(i);
 
 		if (xrandr_support)
 			XRRSelectInput(display, screens[i].root,
 			    RRScreenChangeNotifyMask);
-
-		/* attach windows to a region */
-		/* normal windows */
-		for (j = 0; j < no; j++) {
-			if (!XGetWindowAttributes(display, wins[j], &wa) ||
-			    wa.override_redirect ||
-			    XGetTransientForHint(display, wins[j], &d1))
-				continue;
-
-			state = getstate(wins[j]);
-			manage = state == IconicState;
-			if (wa.map_state == IsViewable || manage)
-				manage_window(wins[j]);
-		}
-		/* transient windows */
-		for (j = 0; j < no; j++) {
-			if (!XGetWindowAttributes(display, wins[j], &wa) ||
-			    wa.override_redirect)
-				continue;
-
-			state = getstate(wins[j]);
-			manage = state == IconicState;
-			if (XGetTransientForHint(display, wins[j], &d1) &&
-			    manage)
-				manage_window(wins[j]);
-                }
-                if (wins) {
-                        XFree(wins);
-			wins = NULL;
-		}
 	}
 }
 
@@ -4487,6 +5776,8 @@ setup_globals(void)
 		err(1, "setup_globals: strdup");
 	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");
 }
 
 void
@@ -4494,7 +5785,7 @@ workaround(void)
 {
 	int			i;
 	Atom			netwmcheck, netwmname, utf8_string;
-	Window			root;
+	Window			root, win;
 
 	/* work around sun jdk bugs, code from wmname */
 	netwmcheck = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
@@ -4502,10 +5793,16 @@ workaround(void)
 	utf8_string = XInternAtom(display, "UTF8_STRING", False);
 	for (i = 0; i < ScreenCount(display); i++) {
 		root = screens[i].root;
+		win = XCreateSimpleWindow(display,root, 0, 0, 1, 1, 0,
+		    screens[i].c[SWM_S_COLOR_UNFOCUS].color,
+		    screens[i].c[SWM_S_COLOR_UNFOCUS].color);
+
 		XChangeProperty(display, root, netwmcheck, XA_WINDOW, 32,
-		    PropModeReplace, (unsigned char *)&root, 1);
-		XChangeProperty(display, root, netwmname, utf8_string, 8,
-		    PropModeReplace, "LG3D", strlen("LG3D"));
+		    PropModeReplace, (unsigned char *)&win,1);
+		XChangeProperty(display, win, netwmcheck, XA_WINDOW, 32,
+		    PropModeReplace, (unsigned char *)&win,1);
+		XChangeProperty(display, win, netwmname, utf8_string, 8,
+		    PropModeReplace, (unsigned char*)"LG3D", strlen("LG3D"));
 	}
 }
 
@@ -4522,6 +5819,7 @@ main(int argc, char *argv[])
 	XEvent			e;
 	int			xfd, i;
 	fd_set			rd;
+	struct sigaction	sact;
 
 	start_argv = argv;
 	fprintf(stderr, "Welcome to scrotwm V%s cvs tag: %s\n",
@@ -4535,17 +5833,28 @@ main(int argc, char *argv[])
 	if (active_wm())
 		errx(1, "other wm running");
 
-	/* handle some signale */
-	installsignal(SIGINT, "INT");
-	installsignal(SIGHUP, "HUP");
-	installsignal(SIGQUIT, "QUIT");
-	installsignal(SIGTERM, "TERM");
-	installsignal(SIGCHLD, "CHLD");
+	/* handle some signals */
+	bzero(&sact, sizeof(sact));
+	sigemptyset(&sact.sa_mask);
+	sact.sa_flags = 0;
+	sact.sa_handler = sighdlr;
+	sigaction(SIGINT, &sact, NULL);
+	sigaction(SIGQUIT, &sact, NULL);
+	sigaction(SIGTERM, &sact, NULL);
+	sigaction(SIGHUP, &sact, NULL);
+
+	sact.sa_handler = sighdlr;
+	sact.sa_flags = SA_NOCLDSTOP;
+	sigaction(SIGCHLD, &sact, NULL);
 
 	astate = XInternAtom(display, "WM_STATE", False);
 	aprot = XInternAtom(display, "WM_PROTOCOLS", False);
 	adelete = XInternAtom(display, "WM_DELETE_WINDOW", False);
 	takefocus = XInternAtom(display, "WM_TAKE_FOCUS", False);
+	a_wmname = XInternAtom(display, "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);
 
 	/* look for local and global conf file */
 	pwd = getpwuid(getuid());
@@ -4558,6 +5867,7 @@ main(int argc, char *argv[])
 	setup_quirks();
 	setup_spawn();
 
+	/* load config */
 	snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE);
 	if (stat(conf, &sb) != -1) {
 		if (S_ISREG(sb.st_mode))
@@ -4572,6 +5882,15 @@ main(int argc, char *argv[])
 	if (cfile)
 		conf_load(cfile);
 
+	custom_region("screen[1]:1280x1009+0+15");
+
+	setup_ewmh();
+	/* set some values to work around bad programs */
+	workaround();
+
+	/* grab existing windows (before we build the bars) */
+	grab_windows();
+
 	/* setup all bars */
 	for (i = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {
@@ -4580,11 +5899,12 @@ main(int argc, char *argv[])
 			bar_setup(r);
 		}
 
-	/* set some values to work around bad programs */
-	workaround();
+	unfocus_all();
 
 	grabkeys();
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 
 	xfd = ConnectionNumber(display);
 	while (running) {
@@ -4626,7 +5946,7 @@ main(int argc, char *argv[])
 			if (ScreenCount(display) > 1 || outputs > 1)
 				XWarpPointer(display, None, rr->s[0].root,
 				    0, 0, 0, 0, rr->g.x,
-				    rr->g.y + bar_enabled ? bar_height : 0);
+				    rr->g.y + (bar_enabled ? bar_height : 0));
 
 			a.id = SWM_ARG_ID_FOCUSCUR;
 			focus(rr, &a);
@@ -4641,6 +5961,10 @@ main(int argc, char *argv[])
 		if (select(xfd + 1, &rd, NULL, NULL, &tv) == -1)
 			if (errno != EINTR)
 				DNPRINTF(SWM_D_MISC, "select failed");
+		if (restart_wm == 1)
+			restart(NULL, NULL);
+		if (search_resp == 1)
+			search_do_resp();
 		if (running == 0)
 			goto done;
 		if (bar_alarm) {
@@ -4649,8 +5973,9 @@ main(int argc, char *argv[])
 		}
 	}
 done:
+	teardown_ewmh();
 	bar_extra_stop();
-
+	XFreeGC(display, bar_gc);
 	XCloseDisplay(display);
 
 	return (0);