X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=9f6d7ff8a57e7b4277ce7b8c38db7a413d8fe4d9;hb=63f6779ee0a5d8458a290284c233767788892448;hp=d6a984c842efc4a385ea0d5eab1c5254bd71ab56;hpb=31f5dfdc37568eebafea134147fbacc83b3e5183;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index d6a984c..9f6d7ff 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -52,7 +52,7 @@
 
 static const char	*cvstag = "$scrotwm$";
 
-#define	SWM_VERSION	"0.9.9"
+#define	SWM_VERSION	"0.9.25"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -84,6 +84,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
@@ -96,8 +100,8 @@ static const char	*cvstag = "$scrotwm$";
 
 /* #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)
+#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)
 #define	SWM_D_MISC		0x0001
 #define	SWM_D_EVENT		0x0002
 #define	SWM_D_WS		0x0004
@@ -148,6 +152,11 @@ u_int32_t		swm_debug = 0
 #define WIDTH(r)		(r)->g.w
 #define HEIGHT(r)		(r)->g.h
 #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"
@@ -157,14 +166,15 @@ char			**start_argv;
 Atom			astate;
 Atom			aprot;
 Atom			adelete;
+Atom			takefocus;
 volatile sig_atomic_t   running = 1;
 int			outputs = 0;
+int			last_focus_event = FocusOut;
 int			(*xerrorxlib)(Display *, XErrorEvent *);
 int			other_wm;
 int			ss_enabled = 0;
 int			xrandr_support;
 int			xrandr_eventbase;
-int			ignore_enter = 0;
 unsigned int		numlockmask = 0;
 Display			*display;
 
@@ -190,9 +200,12 @@ 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			focus_mode = SWM_FOCUS_DEFAULT;
 pid_t			bar_pid;
 GC			bar_gc;
 XGCValues		bar_gcv;
@@ -223,6 +236,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;
 };
@@ -231,14 +245,21 @@ TAILQ_HEAD(swm_region_list, swm_region);
 struct ws_win {
 	TAILQ_ENTRY(ws_win)	entry;
 	Window			id;
-	struct swm_geometry	g;
+	Window			transient;
+	struct ws_win		*child_trans;	/* transient child window */
+	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			transient;
 	int			manual;
 	int			font_size_boundary[SWM_MAX_FONT_STEPS];
 	int			font_steps;
 	int			last_inc;
 	int			can_delete;
+	int			take_focus;
+	int			java;
 	unsigned long		quirks;
 	struct workspace	*ws;	/* always valid */
 	struct swm_screen	*s;	/* always valid, never changes */
@@ -248,63 +269,6 @@ struct ws_win {
 };
 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_invalid
-};
-
 /* layout handlers */
 void	stack(void);
 void	vertical_config(struct workspace *, int);
@@ -313,32 +277,45 @@ void	horizontal_config(struct workspace *, int);
 void	horizontal_stack(struct workspace *, struct swm_geometry *);
 void	max_stack(struct workspace *, struct swm_geometry *);
 
+struct ws_win *find_window(Window);
+
 void	grabbuttons(struct ws_win *, int);
 void	new_region(struct swm_screen *, int, int, int, int);
+void	unmanage_window(struct ws_win *);
+long	getstate(Window);
 
 struct layout {
 	void		(*l_stack)(struct workspace *, struct swm_geometry *);
 	void		(*l_config)(struct workspace *, int);
+	u_int32_t	flags;
+#define SWM_L_FOCUSPREV		(1<<0)
+#define SWM_L_MAPONFOCUS	(1<<1)
+	char		*name;
 } layouts[] =  {
 	/* stack,		configure */
-	{ vertical_stack,	vertical_config},
-	{ horizontal_stack,	horizontal_config},
-	{ max_stack,		NULL},
-	{ NULL,			NULL},
+	{ vertical_stack,	vertical_config,	0,	"[|]" },
+	{ horizontal_stack,	horizontal_config,	0,	"[-]" },
+	{ max_stack,		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)
 
 /* define work spaces */
 struct workspace {
 	int			idx;		/* workspace index */
-	int			restack;	/* restack on switch */
 	struct layout		*cur_layout;	/* current layout handlers */
 	struct ws_win		*focus;		/* may be NULL */
 	struct ws_win		*focus_prev;	/* may be NULL */
 	struct swm_region	*r;		/* may be NULL */
+	struct swm_region	*old_r;		/* may be NULL */
 	struct ws_win_list	winlist;	/* list of windows in ws */
+	struct ws_win_list	unmanagedlist;	/* list of dead windows in ws */
 
 	/* stacker state */
 	struct {
@@ -355,9 +332,9 @@ enum	{ SWM_S_COLOR_BAR, SWM_S_COLOR_BAR_BORDER, SWM_S_COLOR_BAR_FONT,
 	  SWM_S_COLOR_FOCUS, SWM_S_COLOR_UNFOCUS, SWM_S_COLOR_MAX };
 
 /* physical screen mapping */
-#define SWM_WS_MAX		(10)		/* XXX Too small? */
+#define SWM_WS_MAX		(10)
 struct swm_screen {
-	int			idx;		/* screen index */
+	int			idx;	/* screen index */
 	struct swm_region_list	rl;	/* list of regions on this screen */
 	struct swm_region_list	orl;	/* list of old regions */
 	Window			root;
@@ -378,30 +355,36 @@ union arg {
 #define SWM_ARG_ID_FOCUSNEXT	(0)
 #define SWM_ARG_ID_FOCUSPREV	(1)
 #define SWM_ARG_ID_FOCUSMAIN	(2)
-#define SWM_ARG_ID_SWAPNEXT	(3)
-#define SWM_ARG_ID_SWAPPREV	(4)
-#define SWM_ARG_ID_SWAPMAIN	(5)
-#define SWM_ARG_ID_MASTERSHRINK (6)
-#define SWM_ARG_ID_MASTERGROW	(7)
-#define SWM_ARG_ID_MASTERADD	(8)
-#define SWM_ARG_ID_MASTERDEL	(9)
-#define SWM_ARG_ID_STACKRESET	(10)
-#define SWM_ARG_ID_STACKINIT	(11)
-#define SWM_ARG_ID_CYCLEWS_UP	(12)
-#define SWM_ARG_ID_CYCLEWS_DOWN	(13)
-#define SWM_ARG_ID_CYCLESC_UP	(14)
-#define SWM_ARG_ID_CYCLESC_DOWN	(15)
-#define SWM_ARG_ID_STACKINC	(16)
-#define SWM_ARG_ID_STACKDEC	(17)
-#define SWM_ARG_ID_SS_ALL	(0)
-#define SWM_ARG_ID_SS_WINDOW	(1)
-#define SWM_ARG_ID_DONTCENTER	(0)
-#define SWM_ARG_ID_CENTER	(1)
-#define SWM_ARG_ID_KILLWINDOW	(0)
-#define SWM_ARG_ID_DELETEWINDOW	(1)
+#define SWM_ARG_ID_FOCUSCUR	(4)
+#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)
+#define SWM_ARG_ID_MASTERDEL	(23)
+#define SWM_ARG_ID_STACKRESET	(30)
+#define SWM_ARG_ID_STACKINIT	(31)
+#define SWM_ARG_ID_CYCLEWS_UP	(40)
+#define SWM_ARG_ID_CYCLEWS_DOWN	(41)
+#define SWM_ARG_ID_CYCLESC_UP	(42)
+#define SWM_ARG_ID_CYCLESC_DOWN	(43)
+#define SWM_ARG_ID_STACKINC	(50)
+#define SWM_ARG_ID_STACKDEC	(51)
+#define SWM_ARG_ID_SS_ALL	(60)
+#define SWM_ARG_ID_SS_WINDOW	(61)
+#define SWM_ARG_ID_DONTCENTER	(70)
+#define SWM_ARG_ID_CENTER	(71)
+#define SWM_ARG_ID_KILLWINDOW	(80)
+#define SWM_ARG_ID_DELETEWINDOW	(81)
 	char			**argv;
 };
 
+void	focus(struct swm_region *, union arg *);
+void	focus_magic(struct ws_win *, int);
+#define SWM_F_GENERIC		(0)
+#define SWM_F_TRANSIENT		(1)
 /* quirks */
 struct quirk {
 	char			*class;
@@ -534,8 +517,48 @@ dumpevent(XEvent *e)
 		    "remaining\n",
 		    e->xany.window, e->type, QLength(display));
 }
+
+void
+dumpwins(struct swm_region *r, union arg *args)
+{
+	struct ws_win		*win;
+	unsigned int		state;
+	XWindowAttributes	wa;
+
+	if (r->ws == NULL) {
+		fprintf(stderr, "invalid workspace\n");
+		return;
+	}
+
+	fprintf(stderr, "=== managed window list ws %02d ===\n", r->ws->idx);
+
+	TAILQ_FOREACH(win, &r->ws->winlist, entry) {
+		state = getstate(win->id);
+		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, "===== unmanaged window list =====\n");
+	TAILQ_FOREACH(win, &r->ws->unmanagedlist, entry) {
+		state = getstate(win->id);
+		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, "=================================\n");
+}
 #else
 #define dumpevent(e)
+void
+dumpwins(struct swm_region *r, union arg *args)
+{
+}
 #endif /* SWM_DEBUG */
 
 void			expose(XEvent *);
@@ -545,8 +568,8 @@ void			configurerequest(XEvent *);
 void			configurenotify(XEvent *);
 void			destroynotify(XEvent *);
 void			enternotify(XEvent *);
-void			focusin(XEvent *);
-void			focusout(XEvent *);
+void			focusevent(XEvent *);
+void			mapnotify(XEvent *);
 void			mappingnotify(XEvent *);
 void			maprequest(XEvent *);
 void			propertynotify(XEvent *);
@@ -561,8 +584,9 @@ void			(*handler[LASTEvent])(XEvent *) = {
 				[ConfigureNotify] = configurenotify,
 				[DestroyNotify] = destroynotify,
 				[EnterNotify] = enternotify,
-				[FocusIn] = focusin,
-				[FocusOut] = focusout,
+				[FocusIn] = focusevent,
+				[FocusOut] = focusevent,
+				[MapNotify] = mapnotify,
 				[MappingNotify] = mappingnotify,
 				[MapRequest] = maprequest,
 				[PropertyNotify] = propertynotify,
@@ -578,7 +602,7 @@ sighdlr(int sig)
 	switch (sig) {
 	case SIGCHLD:
 		while ((pid = waitpid(WAIT_ANY, NULL, WNOHANG)) != -1) {
-			DNPRINTF(SWM_D_MISC, stderr, "reaping: %d\n", pid);
+			DNPRINTF(SWM_D_MISC, "reaping: %d\n", pid);
 			if (pid <= 0)
 				break;
 		}
@@ -750,8 +774,10 @@ 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 = "";
 
 	if (bar_enabled == 0)
 		return;
@@ -775,21 +801,26 @@ 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) {
+			strlcpy(cn, "", sizeof cn);
 			if (r && r->ws)
-				bar_class_name(s, sizeof s, r->ws->focus);
+				bar_class_name(cn, sizeof cn, r->ws->focus);
 
-			snprintf(loc, sizeof loc, "%d:%d    %s %s    %s",
-			    x++, r->ws->idx + 1, s, bar_ext, bar_vertext);
+			if (stack_enabled)
+				stack = r->ws->cur_layout->name;
+
+			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);
 		}
 	}
-	XSync(display, False);
 	alarm(bar_delay);
 }
 
@@ -803,7 +834,7 @@ void
 bar_toggle(struct swm_region *r, union arg *args)
 {
 	struct swm_region	*tmpr;
-	int			i, j, sc = ScreenCount(display);
+	int			i, sc = ScreenCount(display);
 
 	DNPRINTF(SWM_D_MISC, "bar_toggle\n");
 
@@ -817,9 +848,6 @@ bar_toggle(struct swm_region *r, union arg *args)
 				XMapRaised(display, tmpr->bar_window);
 
 	bar_enabled = !bar_enabled;
-	for (i = 0; i < sc; i++)
-		for (j = 0; j < SWM_WS_MAX; j++)
-			screens[i].ws[j].restack = 1;
 
 	stack();
 	/* must be after stack */
@@ -908,6 +936,39 @@ bar_setup(struct swm_region *r)
 }
 
 void
+set_win_state(struct ws_win *win, long state)
+{
+	long			data[] = {state, None};
+
+	DNPRINTF(SWM_D_EVENT, "set_win_state: window: %lu\n", win->id);
+
+	if (win == NULL)
+		return;
+
+	XChangeProperty(display, win->id, astate, astate, 32, PropModeReplace,
+	    (unsigned char *)data, 2);
+}
+
+long
+getstate(Window w)
+{
+	int			format, status;
+	long			result = -1;
+	unsigned char		*p = NULL;
+	unsigned long		n, extra;
+	Atom			real;
+
+	status = XGetWindowProperty(display, w, astate, 0L, 2L, False, astate,
+	    &real, &format, &n, &extra, (unsigned char **)&p);
+	if (status != Success)
+		return (-1);
+	if (n != 0)
+		result = *((long *)p);
+	XFree(p);
+	return (result);
+}
+
+void
 version(struct swm_region *r, union arg *args)
 {
 	bar_version = !bar_version;
@@ -924,6 +985,9 @@ client_msg(struct ws_win *win, Atom a)
 {
 	XClientMessageEvent	cm;
 
+	if (win == NULL)
+		return;
+
 	bzero(&cm, sizeof cm);
 	cm.type = ClientMessage;
 	cm.window = win->id;
@@ -935,12 +999,38 @@ 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)
 {
 	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;
@@ -981,6 +1071,24 @@ quit(struct swm_region *r, union arg *args)
 }
 
 void
+unmap_window(struct ws_win *win)
+{
+	if (win == NULL)
+		return;
+
+	/* don't unmap again */
+	if (getstate(win->id) == IconicState)
+		return;
+
+	set_win_state(win, IconicState);
+
+	XUnmapWindow(display, win->id);
+	if (win->ws->r)
+		XSetWindowBorder(display, win->id,
+		    win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+}
+
+void
 unmap_all(void)
 {
 	struct ws_win		*win;
@@ -989,7 +1097,7 @@ unmap_all(void)
 	for (i = 0; i < ScreenCount(display); i++)
 		for (j = 0; j < SWM_WS_MAX; j++)
 			TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
-				XUnmapWindow(display, win->id);
+				unmap_window(win);
 }
 
 void
@@ -997,6 +1105,9 @@ fake_keypress(struct ws_win *win, int keysym, int modifiers)
 {
 	XKeyEvent event;
 
+	if (win == NULL)
+		return;
+
 	event.display = display;	/* Ignored, but what the hell */
 	event.window = win->id;
 	event.root = win->s->root;
@@ -1068,16 +1179,50 @@ root_to_region(Window root)
 }
 
 struct ws_win *
-find_window(Window id)
+find_unmanaged_window(Window id)
 {
 	struct ws_win		*win;
 	int			i, j;
 
 	for (i = 0; i < ScreenCount(display); i++)
 		for (j = 0; j < SWM_WS_MAX; j++)
+			TAILQ_FOREACH(win, &screens[i].ws[j].unmanagedlist,
+			    entry)
+				if (id == win->id)
+					return (win);
+	return (NULL);
+}
+
+struct ws_win *
+find_window(Window id)
+{
+	struct ws_win		*win;
+	Window			wrr, wpr, *wcr = NULL;
+	int			i, j, 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);
 }
 
@@ -1118,7 +1263,6 @@ spawn(struct swm_region *r, union arg *args)
 		}
 		exit(0);
 	}
-	wait(0);
 }
 
 void
@@ -1132,22 +1276,111 @@ spawnterm(struct swm_region *r, union arg *args)
 }
 
 void
+kill_refs(struct ws_win *win)
+{
+	int			i, x;
+	struct swm_region	*r;
+	struct workspace	*ws;
+
+	if (win == NULL)
+		return;
+
+	for (i = 0; i < ScreenCount(display); i++)
+		TAILQ_FOREACH(r, &screens[i].rl, entry)
+			for (x = 0; x < SWM_WS_MAX; x++) {
+				ws = &r->s->ws[x];
+				if (win == ws->focus)
+					ws->focus = NULL;
+				if (win == ws->focus_prev)
+					ws->focus_prev = NULL;
+			}
+}
+
+int
+validate_win(struct ws_win *testwin)
+{
+	struct ws_win		*win;
+	struct workspace	*ws;
+	struct swm_region	*r;
+	int			i, x, foundit = 0;
+
+	if (testwin == NULL)
+		return(0);
+
+	for (i = 0, foundit = 0; i < ScreenCount(display); i++)
+		TAILQ_FOREACH(r, &screens[i].rl, entry)
+			for (x = 0; x < SWM_WS_MAX; x++) {
+				ws = &r->s->ws[x];
+				TAILQ_FOREACH(win, &ws->winlist, entry)
+					if (win == testwin)
+						return (0);
+			}
+	return (1);
+}
+
+int
+validate_ws(struct workspace *testws)
+{
+	struct swm_region	*r;
+	struct workspace	*ws;
+	int			foundit, i, x;
+
+	/* validate all ws */
+	for (i = 0, foundit = 0; i < ScreenCount(display); i++)
+		TAILQ_FOREACH(r, &screens[i].rl, entry)
+			for (x = 0; x < SWM_WS_MAX; x++) {
+				ws = &r->s->ws[x];
+				if (ws == testws)
+					return (0);
+			}
+	return (1);
+}
+
+void
 unfocus_win(struct ws_win *win)
 {
+	XEvent			cne;
+
+	DNPRINTF(SWM_D_FOCUS, "unfocus_win: id: %lu\n", WINID(win));
+
 	if (win == NULL)
 		return;
+	if (win->ws == NULL)
+		return;
+
+	if (validate_ws(win->ws))
+		abort();
 
 	if (win->ws->r == NULL)
 		return;
 
-	grabbuttons(win, 0);
-	XSetWindowBorder(display, win->id,
-	    win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+	if (validate_win(win)) {
+		kill_refs(win);
+		return;
+	}
 
 	if (win->ws->focus == win) {
 		win->ws->focus = NULL;
 		win->ws->focus_prev = win;
 	}
+
+	if (validate_win(win->ws->focus)) {
+		kill_refs(win->ws->focus);
+		win->ws->focus = NULL;
+	}
+	if (validate_win(win->ws->focus_prev)) {
+		kill_refs(win->ws->focus_prev);
+		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);
+
 }
 
 void
@@ -1156,44 +1389,75 @@ unfocus_all(void)
 	struct ws_win		*win;
 	int			i, j;
 
-	DNPRINTF(SWM_D_FOCUS, "unfocus_all:\n");
+	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)
 				unfocus_win(win);
-	XSync(display, False);
 }
 
 void
 focus_win(struct ws_win *win)
 {
+	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);
 
 	if (win == NULL)
 		return;
+	if (win->ws == NULL)
+		return;
+
+	if (validate_ws(win->ws))
+		abort();
+	if (validate_win(win)) {
+		kill_refs(win);
+		return;
+	}
+
+	if (validate_win(win)) {
+		kill_refs(win);
+		return;
+	}
+
+	XGetInputFocus(display, &cur_focus, &rr);
+	if ((cfw = find_window(cur_focus)) != NULL)
+		unfocus_win(cfw);
 
-	/* use big hammer to make sure it works under all use cases */
-	unfocus_all();
 	win->ws->focus = win;
 
 	if (win->ws->r != NULL) {
+		/* drain all previous focus events */
+		while (XCheckTypedEvent(display, FocusIn, &cne) == True)
+			;
+
+		if (win->java == 0)
+			XSetInputFocus(display, win->id,
+			    RevertToParent, CurrentTime);
+		grabbuttons(win, 1);
 		XSetWindowBorder(display, win->id,
 		    win->ws->r->s->c[SWM_S_COLOR_FOCUS].color);
-		grabbuttons(win, 1);
-		XSetInputFocus(display, win->id,
-		    RevertToPointerRoot, CurrentTime);
-		XSync(display, False);
+		if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS)
+			XMapRaised(display, win->id);
 	}
 }
 
 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, *winfocus = NULL;
+	struct ws_win		*win;
 	struct workspace	*new_ws, *old_ws;
+	union arg		a;
+
+	if (!(r && r->s))
+		return;
 
 	this_r = r;
 	old_ws = this_r->ws;
@@ -1203,40 +1467,35 @@ switchws(struct swm_region *r, union arg *args)
 	    "%d -> %d\n", r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r),
 	    old_ws->idx, wsid);
 
+	if (new_ws == NULL || old_ws == NULL)
+		return;
 	if (new_ws == old_ws)
 		return;
 
-	/* get focus window */
-	if (new_ws->focus)
-		winfocus = new_ws->focus;
-	else if (new_ws->focus_prev)
-		winfocus = new_ws->focus_prev;
-	else
-		winfocus = TAILQ_FIRST(&new_ws->winlist);
-
 	other_r = new_ws->r;
 	if (other_r == NULL) {
-		/* if the other workspace is hidden, switch windows */
-		/* map new window first to prevent ugly blinking */
+		/* the other workspace is hidden, hide this one */
 		old_ws->r = NULL;
-		old_ws->restack = 1;
-
-		TAILQ_FOREACH(win, &new_ws->winlist, entry)
-			XMapRaised(display, win->id);
-
-		TAILQ_FOREACH(win, &old_ws->winlist, entry)
-			XUnmapWindow(display, win->id);
+		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;
 
-	ignore_enter = 1;
 	stack();
-	focus_win(winfocus);
+	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);
 }
 
 void
@@ -1278,10 +1537,31 @@ 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;
-	int			i;
+	struct swm_region	*rr = NULL;
+	union arg		a;
+	int			i, x, y;
+
+	/* do nothing if we don't have more than one screen */
+	if (!(ScreenCount(display) > 1 || outputs > 1))
+		return;
 
 	i = r->s->idx;
 	switch (args->id) {
@@ -1298,10 +1578,23 @@ cyclescr(struct swm_region *r, union arg *args)
 	default:
 		return;
 	};
-	unfocus_all();
-	XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime);
-	XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, rr->g.x,
-	    rr->g.y + bar_enabled ? bar_height : 0);
+	if (rr == NULL)
+		return;
+
+	/* move mouse to region */
+	x = rr->g.x + 1;
+	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;
+	focus(rr, &a);
+
+	if (rr->ws->focus) {
+		/* move to focus window */
+		x = rr->ws->focus->g.x + 1;
+		y = rr->ws->focus->g.y + 1;
+		XWarpPointer(display, None, rr->s[i].root, 0, 0, 0, 0, x, y);
+	}
 }
 
 void
@@ -1350,40 +1643,121 @@ swapwin(struct swm_region *r, union arg *args)
 			else
 				return;
                 }
+		if (target == NULL || source == NULL)
+			return;
 		source->ws->focus_prev = target;
 		TAILQ_REMOVE(wl, target, entry);
 		TAILQ_INSERT_BEFORE(source, target, entry);
 		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;
 	}
 
-	ignore_enter = 1;
 	stack();
 }
 
 void
+focus_prev(struct ws_win *win)
+{
+	struct ws_win		*winfocus = NULL, *winlostfocus = NULL;
+	struct ws_win		*cur_focus = NULL;
+	struct ws_win_list	*wl = NULL;
+	struct workspace	*ws = NULL;
+
+	DNPRINTF(SWM_D_FOCUS, "focus_prev: id %lu\n", WINID(win));
+
+	if (!(win && win->ws))
+		return;
+
+	ws = win->ws;
+	wl = &ws->winlist;
+	cur_focus = ws->focus;
+	winlostfocus = cur_focus;
+
+	/* pickle, just focus on whatever */
+	if (cur_focus == NULL) {
+		/* use prev_focus if valid */
+		if (ws->focus_prev && ws->focus_prev != cur_focus &&
+		    find_window(WINID(ws->focus_prev)))
+			winfocus = ws->focus_prev;
+		if (winfocus == NULL)
+			winfocus = TAILQ_FIRST(wl);
+		goto done;
+	}
+
+	/* if transient focus on parent */
+	if (cur_focus->transient) {
+		winfocus = find_window(cur_focus->transient);
+		goto done;
+	}
+
+	/* 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;
+		else
+			winfocus = TAILQ_PREV(win, ws_win_list, entry);
+		if (winfocus)
+			goto done;
+	}
+
+	if (cur_focus == win)
+		winfocus = TAILQ_PREV(win, ws_win_list, entry);
+	if (winfocus == NULL)
+		winfocus = TAILQ_LAST(wl, ws_win_list);
+	if (winfocus == NULL || winfocus == win)
+		winfocus = TAILQ_NEXT(cur_focus, entry);
+done:
+	if (winfocus == winlostfocus || winfocus == NULL)
+		return;
+
+	focus_magic(winfocus, SWM_F_GENERIC);
+}
+
+void
 focus(struct swm_region *r, union arg *args)
 {
-	struct ws_win		*winfocus, *winlostfocus;
-	struct ws_win_list	*wl;
-	struct ws_win		*cur_focus;
+	struct ws_win		*winfocus = NULL, *winlostfocus = NULL;
+	struct ws_win		*cur_focus = NULL;
+	struct ws_win_list	*wl = NULL;
+	struct workspace	*ws = NULL;
+
+	if (!(r && r->ws))
+		return;
 
 	DNPRINTF(SWM_D_FOCUS, "focus: id %d\n", args->id);
 
-	cur_focus = r->ws->focus;
-	if (cur_focus == NULL)
+	/* treat FOCUS_CUR special */
+	if (args->id == SWM_ARG_ID_FOCUSCUR) {
+		if (r->ws->focus)
+			winfocus = r->ws->focus;
+		else if (r->ws->focus_prev)
+			winfocus = r->ws->focus_prev;
+		else
+			winfocus = TAILQ_FIRST(&r->ws->winlist);
+
+		focus_magic(winfocus, SWM_F_GENERIC);
 		return;
+	}
 
-	wl = &cur_focus->ws->winlist;
+	if ((cur_focus = r->ws->focus) == NULL)
+		return;
+	ws = r->ws;
+	wl = &ws->winlist;
 
 	winlostfocus = cur_focus;
 
 	switch (args->id) {
-	case SWM_ARG_ID_FOCUSPREV:
+ 	case SWM_ARG_ID_FOCUSPREV:
 		winfocus = TAILQ_PREV(cur_focus, ws_win_list, entry);
 		if (winfocus == NULL)
 			winfocus = TAILQ_LAST(wl, ws_win_list);
@@ -1399,8 +1773,6 @@ focus(struct swm_region *r, union arg *args)
 		winfocus = TAILQ_FIRST(wl);
 		if (winfocus == cur_focus)
 			winfocus = cur_focus->ws->focus_prev;
-		if (winfocus == NULL)
-			return;
 		break;
 
 	default:
@@ -1410,9 +1782,7 @@ focus(struct swm_region *r, union arg *args)
 	if (winfocus == winlostfocus || winfocus == NULL)
 		return;
 
-	XMapRaised(display, winfocus->id);
-	focus_win(winfocus);
-	XSync(display, False);
+	focus_magic(winfocus, SWM_F_GENERIC);
 }
 
 void
@@ -1420,6 +1790,7 @@ cycle_layout(struct swm_region *r, union arg *args)
 {
 	struct workspace	*ws = r->ws;
 	struct ws_win		*winfocus;
+	union arg		a;
 
 	DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx);
 
@@ -1429,9 +1800,10 @@ cycle_layout(struct swm_region *r, union arg *args)
 	if (ws->cur_layout->l_stack == NULL)
 		ws->cur_layout = &layouts[0];
 
-	ignore_enter = 1;
 	stack();
-	focus_win(winfocus);
+	a.id = SWM_ARG_ID_FOCUSCUR;
+	focus(r, &a);
+	bar_update();
 }
 
 void
@@ -1471,14 +1843,28 @@ stack(void) {
 				g.y += bar_height;
 				g.h -= bar_height;
 			}
-
-			r->ws->restack = 0;
 			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--;
-	XSync(display, False);
+}
+
+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
@@ -1487,10 +1873,33 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 	unsigned int		mask;
 	XWindowChanges		wc;
 
+	if (win == NULL)
+		return;
+
 	bzero(&wc, sizeof wc);
 	mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
-	if ((win->quirks & SWM_Q_FULLSCREEN) && (win->g.w == WIDTH(r)) &&
-	    (win->g.h == HEIGHT(r)))
+
+	/*
+	 * 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) ) {
+		/*
+		 * 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;
@@ -1498,24 +1907,45 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 		win->g.w = (double)WIDTH(r) * dialog_ratio;
 		win->g.h = (double)HEIGHT(r) * dialog_ratio;
 	}
+
+	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;
+                win->g.y = r->g.y + (HEIGHT(r) - win->g.h) / 2;
+	}
+
+	/* 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 )
+		win->g.x = r->g.x;
+	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);
+	if (win->g.y < r->g.y )
+		win->g.y = r->g.y;
+	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.x = win->g.x;
+	wc.y = win->g.y;
 	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;
-	}
 
-	/* adjust for region */
-	wc.x += r->g.x;
-	wc.y += r->g.y;
+	/*
+	 * Retain floater and transient geometry for correct positioning
+	 * when ws changes region
+	 */
+	store_float_geom(win, r);
 
-	DNPRINTF(SWM_D_STACK, "stack_floater: win %lu x %d y %d w %d h %d\n",
+	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);
 }
 
 /*
@@ -1556,13 +1986,14 @@ 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;
 	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;
 	int			split, colno, winno, mwin, msize, mscale;
-	int			remain, missing, v_slice;
+	int			remain, missing, v_slice, reconfigure;
 	unsigned int		mask;
 
 	DNPRINTF(SWM_D_STACK, "stack_master: workspace: %d\n rot=%s flip=%s",
@@ -1682,22 +2113,42 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 			win_g.y += last_h + 2;
 
 		bzero(&wc, sizeof wc);
-		wc.border_width = 1;
+		if (bar_enabled == 0 && winno == 1){
+			wc.border_width = 0;
+			win_g.w += 2;
+			win_g.h += 2;
+		} else
+			wc.border_width = 1;
+		reconfigure = 0;
 		if (rot) {
-			win->g.x = wc.x = win_g.y;
-			win->g.y = wc.y = win_g.x;
-			win->g.w = wc.width = win_g.h;
-			win->g.h = wc.height = win_g.w;
+			if (win->g.x != win_g.y || win->g.y != win_g.x ||
+			    win->g.w != win_g.h || win->g.h != win_g.w) {
+				reconfigure = 1;
+				win->g.x = wc.x = win_g.y;
+				win->g.y = wc.y = win_g.x;
+				win->g.w = wc.width = win_g.h;
+				win->g.h = wc.height = win_g.w;
+			}
 		} else {
-			win->g.x = wc.x = win_g.x;
-			win->g.y = wc.y = win_g.y;
-			win->g.w = wc.width = win_g.w;
-			win->g.h = wc.height = win_g.h;
+			if (win->g.x != win_g.x || win->g.y != win_g.y ||
+			    win->g.w != win_g.w || win->g.h != win_g.h) {
+				reconfigure = 1;
+				win->g.x = wc.x = win_g.x;
+				win->g.y = wc.y = win_g.y;
+				win->g.w = wc.width = win_g.w;
+				win->g.h = wc.height = win_g.h;
+			}
 		}
-		adjust_font(win);
-		mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
-		XConfigureWindow(display, win->id, mask, &wc);
-		XMapRaised(display, win->id);
+		if (reconfigure) {
+			adjust_font(win);
+			mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+			XConfigureWindow(display, win->id, mask, &wc);
+			configreq_win(win);
+		}
+
+		if (XGetWindowAttributes(display, win->id, &wa))
+			if (wa.map_state == IsUnmapped)
+				XMapRaised(display, win->id);
 
 		last_h = win_g.h;
 		i++;
@@ -1804,7 +2255,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);
 }
@@ -1815,35 +2266,66 @@ max_stack(struct workspace *ws, struct swm_geometry *g)
 {
 	XWindowChanges		wc;
 	struct swm_geometry	gg = *g;
-	struct ws_win		*win;
+	struct ws_win		*win, *wintrans = NULL, *parent = NULL;
 	unsigned int		mask;
 	int			winno;
 
-	/* XXX this function needs to be rewritten it sucks crap */
-
 	DNPRINTF(SWM_D_STACK, "max_stack: workspace: %d\n", ws->idx);
 
+	if (ws == NULL)
+		return;
+
 	winno = count_win(ws, 0);
 	if (winno == 0 && count_win(ws, 1) == 0)
 		return;
 
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
-		if (win->transient != 0 || win->floating != 0) {
-			if (win == ws->focus) {
-				stack_floater(win, ws->r);
-				XMapRaised(display, win->id);
-				focus_win(win); /* override */
-			}
-		} else {
+		if (win->transient) {
+			wintrans = win;
+			parent = find_window(win->transient);
+			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 = 1;
+				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;
+				win->g.h = wc.height = gg.h + 2;
+			}
 			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)
+			if (!(ScreenCount(display) > 1 || outputs > 1))
+				unmap_window(win);
+	}
+
+	/* put the last transient on top */
+	if (wintrans) {
+		if (parent)
+			XMapRaised(display, parent->id);
+		stack_floater(wintrans, ws->r);
+		focus_magic(wintrans, SWM_F_TRANSIENT);
 	}
 }
 
@@ -1851,36 +2333,30 @@ void
 send_to_ws(struct swm_region *r, union arg *args)
 {
 	int			wsid = args->id;
-	struct ws_win		*win = r->ws->focus, *winfocus = NULL;
+	struct ws_win		*win = win;
 	struct workspace	*ws, *nws;
 	Atom			ws_idx_atom = 0;
 	unsigned char		ws_idx_str[SWM_PROPLEN];
+	union arg		a;
 
+	if (r && r->ws)
+		win = r->ws->focus;
+	else
+		return;
 	if (win == NULL)
 		return;
+	if (win->ws->idx == wsid)
+		return;
 
 	DNPRINTF(SWM_D_MOVE, "send_to_ws: win: %lu\n", win->id);
 
 	ws = win->ws;
 	nws = &win->s->ws[wsid];
 
-	/* find a window to focus */
-	winfocus = TAILQ_PREV(win, ws_win_list, entry);
-	if (TAILQ_FIRST(&ws->winlist) == win)
-		winfocus = TAILQ_NEXT(win, entry);
-	else {
-		winfocus = TAILQ_PREV(ws->focus, ws_win_list, entry);
-		if (winfocus == NULL)
-			winfocus = TAILQ_LAST(&ws->winlist, ws_win_list);
-	}
-	/* out of windows in ws so focus on nws instead */
-	if (winfocus == NULL)
-		winfocus = win;
-
-	XUnmapWindow(display, win->id);
-
+	a.id = SWM_ARG_ID_FOCUSPREV;
+	focus(r, &a);
+	unmap_window(win);
 	TAILQ_REMOVE(&ws->winlist, win, entry);
-
 	TAILQ_INSERT_TAIL(&nws->winlist, win, entry);
 	win->ws = nws;
 
@@ -1893,14 +2369,7 @@ 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);
 	}
-
-	if (count_win(nws, 1) == 1)
-		nws->focus = win;
-	ws->restack = 1;
-	nws->restack = 1;
-
 	stack();
-	focus_win(winfocus);
 }
 
 void
@@ -1922,14 +2391,35 @@ void
 floating_toggle(struct swm_region *r, union arg *args)
 {
 	struct ws_win	*win = r->ws->focus;
+	union arg	a;
 
 	if (win == NULL)
 		return;
 
-	win->floating = !win->floating;
-	win->manual = 0;
+	/* reject floating toggles in max stack mode */
+	if (r->ws->cur_layout == &layouts[SWM_MAX_STACK])
+		return;
+
+	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;
+	}
+
 	stack();
-	focus_win(win);
+	a.id = SWM_ARG_ID_FOCUSCUR;
+	focus(win->ws->r, &a);
 }
 
 void
@@ -1955,7 +2445,7 @@ resize_window(struct ws_win *win, int center)
 	    win->id, wc.x, wc.y, wc.width, wc.height);
 
 	XConfigureWindow(display, win->id, mask, &wc);
-	config_win(win);
+	configreq_win(win);
 }
 
 void
@@ -1963,17 +2453,43 @@ resize(struct ws_win *win, union arg *args)
 {
 	XEvent			ev;
 	Time			time = 0;
+	struct swm_region	*r = win->ws->r;
+	int			relx, rely;
+	union arg		a;
+
 
-	DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %d\n",
+	DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
 
 	if (!(win->transient != 0 || win->floating != 0))
 		return;
 
+	/* reject resizes in max mode for floaters (transient ok) */
+	if (win->floatmaxed)
+		return;
+
+	win->manual = 1;
+	/* raise the window = move to last in window list */
+	a.id = SWM_ARG_ID_MOVELAST;
+	swapwin(r, &a);
+	stack();
+
 	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;
+	else
+		relx = r->g.x + r->g.w - win->g.x - 2;
+
+	if ( win->g.y + win->g.h < r->g.y + r->g.h - 1)
+		rely = win->g.h;
+	else
+		rely = r->g.y + r->g.h - win->g.y - 2;
+
+	XWarpPointer(display, None, win->id, 0, 0, 0, 0, relx, rely);
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
@@ -1984,6 +2500,13 @@ resize(struct ws_win *win, union arg *args)
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
+			/* do not allow resize outside of region */
+			if (	ev.xmotion.x_root < r->g.x ||
+				ev.xmotion.x_root > r->g.x + r->g.w - 1 ||
+				ev.xmotion.y_root < r->g.y ||
+				ev.xmotion.y_root > r->g.y + r->g.h - 1)
+				continue;
+
 			if (ev.xmotion.x <= 1)
 				ev.xmotion.x = 1;
 			if (ev.xmotion.y <= 1)
@@ -2004,6 +2527,8 @@ 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);
@@ -2029,7 +2554,7 @@ move_window(struct ws_win *win)
 	    win->id, wc.x, wc.y, wc.width, wc.height);
 
 	XConfigureWindow(display, win->id, mask, &wc);
-	config_win(win);
+	configreq_win(win);
 }
 
 void
@@ -2037,21 +2562,30 @@ move(struct ws_win *win, union arg *args)
 {
 	XEvent			ev;
 	Time			time = 0;
-	int			restack = 0;
+	struct swm_region	*r = win->ws->r;
+	union arg		a;
 
-	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %d\n",
+	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
 
-	if (win->floating == 0) {
+	/* 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) {
 		win->floating = 1;
-		win->manual = 1;
-		restack = 1;
 	}
 
+	/* raise the window = move to last in window list */
+	a.id = SWM_ARG_ID_MOVELAST;
+	swapwin(r, &a);
+	stack();
+
 	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
 	    GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
 		return;
-	XWarpPointer(display, None, win->id, 0, 0, 0, 0, 0, 0);
+	XWarpPointer(display, None, win->id, 0, 0, 0, 0, -1, -1);
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
@@ -2062,6 +2596,13 @@ move(struct ws_win *win, union arg *args)
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
+			/* don't allow to move window origin out of region */
+			if (	ev.xmotion.x_root < r->g.x ||
+				ev.xmotion.x_root > r->g.x + r->g.w - 1 ||
+				ev.xmotion.y_root < r->g.y ||
+				ev.xmotion.y_root > r->g.y + r->g.h - 1)
+				continue;
+
 			win->g.x = ev.xmotion.x_root;
 			win->g.y = ev.xmotion.y_root;
 
@@ -2078,18 +2619,83 @@ 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));
 }
 
+/* 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_dumpwins,
+	kf_invalid
+};
+
 /* key definitions */
-void dummykeyfunc(struct swm_region *r, union arg *args) {};
-void legacyfunc(struct swm_region *r, union arg *args) {};
+void
+dummykeyfunc(struct swm_region *r, union arg *args)
+{
+};
+
+void
+legacyfunc(struct swm_region *r, union arg *args)
+{
+};
 
 struct keyfunc {
 	char			name[SWM_FUNCNAME_LEN];
@@ -2127,6 +2733,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} },
@@ -2149,6 +2756,7 @@ struct keyfunc {
 	{ "spawn_lock",		legacyfunc,	{0} },
 	{ "spawn_initscr",	legacyfunc,	{0} },
 	{ "spawn_custom",	dummykeyfunc,	{0} },
+	{ "dumpwins",		dumpwins,	{0} },
 	{ "invalid key func",	NULL,		{0} },
 };
 struct key {
@@ -2477,6 +3085,7 @@ parsekeys(char *keystr, unsigned int currmod, unsigned int *mod, KeySym *ks)
 	DNPRINTF(SWM_D_KEY, "parsekeys: leave ok\n");
 	return (0);
 }
+
 char *
 strdupsafe(char *str)
 {
@@ -2485,6 +3094,7 @@ strdupsafe(char *str)
 	else
 		return (strdup(str));
 }
+
 void
 setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name)
 {
@@ -2565,6 +3175,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 	}
 	DNPRINTF(SWM_D_KEY, "setkeybinding: leave\n");
 }
+
 int
 setconfbinding(char *selector, char *value, int flags)
 {
@@ -2611,6 +3222,7 @@ setconfbinding(char *selector, char *value, int flags)
 	DNPRINTF(SWM_D_KEY, "setconfbinding: no match\n");
 	return (1);
 }
+
 void
 setup_keys(void)
 {
@@ -2644,6 +3256,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);
@@ -2667,7 +3280,11 @@ 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");
+#ifdef SWM_DEBUG
+	setkeybinding(MODKEY|ShiftMask,	XK_d,		kf_dumpwins,	NULL);
+#endif
 }
+
 void
 updatenumlockmask(void)
 {
@@ -2722,87 +3339,17 @@ grabbuttons(struct ws_win *win, int focused)
 	updatenumlockmask();
 	XUngrabButton(display, AnyButton, AnyModifier, win->id);
 	if(focused) {
-		for (i = 0; i < LENGTH(buttons); i++)
-			if (buttons[i].action == client_click)
-				for (j = 0; j < LENGTH(modifiers); j++)
-					XGrabButton(display, buttons[i].button,
-					    buttons[i].mask | modifiers[j],
-					    win->id, False, BUTTONMASK,
-					    GrabModeAsync, GrabModeSync, None,
-					    None);
-	} else
-		XGrabButton(display, AnyButton, AnyModifier, win->id, False,
-		    BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
-}
-
-void
-expose(XEvent *e)
-{
-	DNPRINTF(SWM_D_EVENT, "expose: window: %lu\n", e->xexpose.window);
-}
-
-void
-keypress(XEvent *e)
-{
-	unsigned int		i;
-	KeySym			keysym;
-	XKeyEvent		*ev = &e->xkey;
-
-	DNPRINTF(SWM_D_EVENT, "keypress: window: %lu\n", ev->window);
-
-	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) {
-			if (keys[i].funcid == kf_spawn_custom)
-				spawn_custom(
-				    root_to_region(ev->root),
-				    &(keyfuncs[keys[i].funcid].args),
-				    keys[i].spawn_name
-				    );
-			else
-				keyfuncs[keys[i].funcid].func(
-				    root_to_region(ev->root),
-				    &(keyfuncs[keys[i].funcid].args)
-				    );
-		}
-}
-
-void
-buttonpress(XEvent *e)
-{
-	XButtonPressedEvent	*ev = &e->xbutton;
-
-	struct ws_win		*win;
-	int			i, action;
-
-	DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window);
-
-	action = root_click;
-	if ((win = find_window(ev->window)) == NULL)
-		return;
-	else {
-		focus_win(win);
-		action = client_click;
-	}
-
-	for (i = 0; i < LENGTH(buttons); i++)
-		if (action == buttons[i].action && buttons[i].func &&
-		    buttons[i].button == ev->button &&
-		    CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
-			buttons[i].func(win, &buttons[i].args);
-}
-
-void
-set_win_state(struct ws_win *win, long state)
-{
-	long			data[] = {state, None};
-
-	DNPRINTF(SWM_D_EVENT, "set_win_state: window: %lu\n", win->id);
-
-	XChangeProperty(display, win->id, astate, astate, 32, PropModeReplace,
-	    (unsigned char *)data, 2);
+		for (i = 0; i < LENGTH(buttons); i++)
+			if (buttons[i].action == client_click)
+				for (j = 0; j < LENGTH(modifiers); j++)
+					XGrabButton(display, buttons[i].button,
+					    buttons[i].mask | modifiers[j],
+					    win->id, False, BUTTONMASK,
+					    GrabModeAsync, GrabModeSync, None,
+					    None);
+	} else
+		XGrabButton(display, AnyButton, AnyModifier, win->id, False,
+		    BUTTONMASK, GrabModeAsync, GrabModeSync, None, None);
 }
 
 const char *quirkname[] = {
@@ -2821,8 +3368,10 @@ parsequirks(char *qstr, unsigned long *quirk)
 {
 	char			*cp, *name;
 	int			i;
+
 	if (quirk == NULL)
 		return (1);
+
 	cp = qstr;
 	*quirk = 0;
 	while ((name = strsep(&cp, SWM_Q_WS)) != NULL) {
@@ -2847,10 +3396,12 @@ parsequirks(char *qstr, unsigned long *quirk)
 	}
 	return (0);
 }
+
 void
 setquirk(const char *class, const char *name, const int quirk)
 {
 	int			i, j;
+
 	/* find existing */
 	for (i = 0; i < quirks_length; i++) {
 		if (!strcmp(quirks[i].class, class) &&
@@ -2920,6 +3471,7 @@ setquirk(const char *class, const char *name, const int quirk)
 		}
 	}
 }
+
 int
 setconfquirk(char *selector, char *value, int flags)
 {
@@ -2942,8 +3494,7 @@ 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("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);
@@ -2959,11 +3510,13 @@ setup_quirks(void)
 /* conf file stuff */
 #define SWM_CONF_FILE	"scrotwm.conf"
 
-enum	{ SWM_S_BAR_DELAY, SWM_S_BAR_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_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_FOCUS_MODE, SWM_S_BAR_FONT, SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM,
+	  SWM_S_SS_APP, SWM_S_DIALOG_RATIO
+	};
 
 int
 setconfvalue(char *selector, char *value, int flags)
@@ -2975,9 +3528,19 @@ setconfvalue(char *selector, char *value, int flags)
 	case SWM_S_BAR_ENABLED:
 		bar_enabled = 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;
@@ -2996,6 +3559,16 @@ setconfvalue(char *selector, char *value, int flags)
 	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_BAR_FONT:
 		free(bar_fonts[0]);
 		if ((bar_fonts[0] = strdup(value)) == NULL)
@@ -3069,7 +3642,9 @@ struct config_option configopt[] = {
 	{ "bar_action",			setconfvalue,	SWM_S_BAR_ACTION },
 	{ "bar_delay",			setconfvalue,	SWM_S_BAR_DELAY },
 	{ "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 },
@@ -3084,7 +3659,8 @@ struct config_option configopt[] = {
 	{ "screenshot_app",		setconfvalue,	SWM_S_SS_APP },
 	{ "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 },
 };
 
 
@@ -3184,10 +3760,20 @@ conf_load(char *filename)
 	return (0);
 }
 
+void
+set_child_transient(struct ws_win *win)
+{
+	struct ws_win		*parent;
+
+	parent = find_window(win->transient);
+	if (parent)
+		parent->child_trans = win;
+}
+
 struct ws_win *
 manage_window(Window id)
 {
-	Window			trans;
+	Window			trans = 0;
 	struct workspace	*ws;
 	struct ws_win		*win, *ww;
 	int			format, i, ws_idx, n, border_me = 0;
@@ -3201,7 +3787,18 @@ manage_window(Window id)
 	XWindowChanges		wc;
 
 	if ((win = find_window(id)) != NULL)
-			return (win);	/* already being managed */
+		return (win);	/* already being managed */
+
+	/* see if we are on the unmanaged list */
+	if ((win = find_unmanaged_window(id)) != NULL) {
+		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);
+		return (win);
+	}
 
 	if ((win = calloc(1, sizeof(struct ws_win))) == NULL)
 		errx(1, "calloc: failed to allocate memory for new window");
@@ -3212,18 +3809,22 @@ manage_window(Window id)
 		XGetWindowProperty(display, id, ws_idx_atom, 0, SWM_PROPLEN,
 		    False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
 	XGetWindowAttributes(display, id, &win->wa);
+	XGetWMNormalHints(display, id, &win->sh, &mask);
 	XGetTransientForHint(display, id, &trans);
-	XGetWMNormalHints(display, id, &win->sh, &mask); /* XXX function? */
 	if (trans) {
 		win->transient = trans;
-		DNPRINTF(SWM_D_MISC, "manage_window: win %u transient %u\n",
-		    (unsigned)win->id, win->transient);
+		set_child_transient(win);
+		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++)
+		for (i = 0, pp = prot; i < n; i++, pp++) {
+			if (*pp == takefocus)
+				win->take_focus = 1;
 			if (*pp == adelete)
 				win->can_delete = 1;
+		}
 		if (prot)
 			XFree(prot);
 	}
@@ -3245,12 +3846,15 @@ manage_window(Window id)
 	} else {
 		ws = r->ws;
 		/* this should launch transients in the same ws as parent */
-		/* XXX doesn't work for intel xrandr */
 		if (id && trans)
 			if ((ww = find_window(trans)) != NULL)
 				if (ws->r) {
 					ws = ww->ws;
-					r = ww->ws->r;
+					if (ww->ws->r)
+						r = ww->ws->r;
+					else
+						fprintf(stderr,
+						    "fix this bug mcbride\n");
 					border_me = 1;
 				}
 	}
@@ -3265,6 +3869,8 @@ manage_window(Window id)
 	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;
 
 	/* Set window properties so we can remember this after reincarnation */
 	if (ws_idx_atom && prop == NULL &&
@@ -3279,13 +3885,22 @@ manage_window(Window id)
 	if (XGetClassHint(display, win->id, &win->ch)) {
 		DNPRINTF(SWM_D_CLASS, "class: %s name: %s\n",
 		    win->ch.res_class, win->ch.res_name);
+
+		/* java is retarded so treat it special */
+		if (strstr(win->ch.res_name, "sun-awt")) {
+			win->java = 1;
+			border_me = 1;
+		}
+
 		for (i = 0; i < quirks_length; i++){
 			if (!strcmp(win->ch.res_class, quirks[i].class) &&
 			    !strcmp(win->ch.res_name, quirks[i].name)) {
 				DNPRINTF(SWM_D_CLASS, "found: %s name: %s\n",
 				    win->ch.res_class, win->ch.res_name);
-				if (quirks[i].quirk & SWM_Q_FLOAT)
+				if (quirks[i].quirk & SWM_Q_FLOAT) {
 					win->floating = 1;
+					border_me = 1;
+				}
 				win->quirks = quirks[i].quirk;
 			}
 		}
@@ -3321,6 +3936,7 @@ manage_window(Window id)
 		wc.border_width = 1;
 		mask = CWBorderWidth;
 		XConfigureWindow(display, win->id, mask, &wc);
+		configreq_win(win);
 	}
 
 	XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
@@ -3336,26 +3952,142 @@ manage_window(Window id)
 }
 
 void
-unmanage_window(struct ws_win *win)
+free_window(struct ws_win *win)
 {
-	struct workspace	*ws;
+	DNPRINTF(SWM_D_MISC, "free_window:  %lu\n", win->id);
 
 	if (win == NULL)
 		return;
 
-	DNPRINTF(SWM_D_MISC, "unmanage_window:  %lu\n", win->id);
-
-	ws = win->ws;
-	TAILQ_REMOVE(&win->ws->winlist, win, entry);
+	/* needed for restart wm */
 	set_win_state(win, WithdrawnState);
+
+	TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
+
 	if (win->ch.res_class)
 		XFree(win->ch.res_class);
 	if (win->ch.res_name)
 		XFree(win->ch.res_name);
+
+	kill_refs(win);
+
+	/* paint memory */
+	memset(win, 0xff, sizeof *win);	/* XXX kill later */
+
 	free(win);
 }
 
 void
+unmanage_window(struct ws_win *win)
+{
+	struct ws_win		*parent;
+
+	if (win == NULL)
+		return;
+
+	DNPRINTF(SWM_D_MISC, "unmanage_window:  %lu\n", win->id);
+
+	if (win->transient) {
+		parent = find_window(win->transient);
+		if (parent)
+			parent->child_trans = NULL;
+	}
+
+	/* work around for mplayer going full screen */
+	if (!win->floating)
+		focus_prev(win);
+
+	TAILQ_REMOVE(&win->ws->winlist, win, entry);
+	TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
+
+	kill_refs(win);
+}
+
+void
+focus_magic(struct ws_win *win, int do_trans)
+{
+	DNPRINTF(SWM_D_FOCUS, "focus_magic: %lu %d\n", WINID(win), do_trans);
+
+	if (win == NULL)
+		return;
+
+	if (do_trans == SWM_F_TRANSIENT && 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);
+		}
+	} else {
+		/* regular focus */
+		focus_win(win);
+		if (win->take_focus)
+			client_msg(win, takefocus);
+	}
+}
+
+void
+expose(XEvent *e)
+{
+	DNPRINTF(SWM_D_EVENT, "expose: window: %lu\n", e->xexpose.window);
+}
+
+void
+keypress(XEvent *e)
+{
+	unsigned int		i;
+	KeySym			keysym;
+	XKeyEvent		*ev = &e->xkey;
+
+	DNPRINTF(SWM_D_EVENT, "keypress: window: %lu\n", ev->window);
+
+	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) {
+			if (keys[i].funcid == kf_spawn_custom)
+				spawn_custom(
+				    root_to_region(ev->root),
+				    &(keyfuncs[keys[i].funcid].args),
+				    keys[i].spawn_name
+				    );
+			else
+				keyfuncs[keys[i].funcid].func(
+				    root_to_region(ev->root),
+				    &(keyfuncs[keys[i].funcid].args)
+				    );
+		}
+}
+
+void
+buttonpress(XEvent *e)
+{
+	struct ws_win		*win;
+	int			i, action;
+	XButtonPressedEvent	*ev = &e->xbutton;
+
+	DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window);
+
+	action = root_click;
+	if ((win = find_window(ev->window)) == NULL)
+		return;
+
+	focus_magic(win, SWM_F_TRANSIENT);
+	action = client_click;
+
+	for (i = 0; i < LENGTH(buttons); i++)
+		if (action == buttons[i].action && buttons[i].func &&
+		    buttons[i].button == ev->button &&
+		    CLEANMASK(buttons[i].mask) == CLEANMASK(ev->state))
+			buttons[i].func(win, &buttons[i].args);
+}
+
+void
 configurerequest(XEvent *e)
 {
 	XConfigureRequestEvent	*ev = &e->xconfigurerequest;
@@ -3364,7 +4096,8 @@ configurerequest(XEvent *e)
 	XWindowChanges		wc;
 
 	if ((win = find_window(ev->window)) == NULL)
-		new = 1;
+		if ((win = find_unmanaged_window(ev->window)) == NULL)
+			new = 1;
 
 	if (new) {
 		DNPRINTF(SWM_D_EVENT, "configurerequest: new window: %lu\n",
@@ -3390,27 +4123,8 @@ configurerequest(XEvent *e)
 				win->g.w = ev->width;
 			if (ev->value_mask & CWHeight)
 				win->g.h = ev->height;
-			if (win->ws->r != NULL) {
-				/* this seems to be full screen */
-				if (win->g.w >= WIDTH(win->ws->r)) {
-					win->g.x = 0;
-					win->g.w = WIDTH(win->ws->r);
-					ev->value_mask |= CWX | CWWidth;
-				}
-				if (win->g.h >= HEIGHT(win->ws->r)) {
-					/* kill border */
-					win->g.y = 0;
-					win->g.h = HEIGHT(win->ws->r);
-					ev->value_mask |= CWY | CWHeight;
-				}
-			}
-			if ((ev->value_mask & (CWX | CWY)) &&
-			    !(ev->value_mask & (CWWidth | CWHeight)))
-				config_win(win);
-			XMoveResizeWindow(display, win->id,
-			    win->g.x, win->g.y, win->g.w, win->g.h);
-		} else
-			config_win(win);
+		}
+		config_win(win);
 	}
 }
 
@@ -3423,12 +4137,10 @@ configurenotify(XEvent *e)
 	DNPRINTF(SWM_D_EVENT, "configurenotify: window: %lu\n",
 	    e->xconfigure.window);
 
-	XMapWindow(display, e->xconfigure.window);
 	win = find_window(e->xconfigure.window);
 	if (win) {
 		XGetWMNormalHints(display, win->id, &win->sh, &mask);
 		adjust_font(win);
-		XMapWindow(display, win->id);
 		if (font_adjusted)
 			stack();
 	}
@@ -3437,69 +4149,200 @@ configurenotify(XEvent *e)
 void
 destroynotify(XEvent *e)
 {
-	struct ws_win		*win, *winfocus = NULL;
-	struct workspace	*ws;
-	struct ws_win_list	*wl;
-
+	struct ws_win		*win;
 	XDestroyWindowEvent	*ev = &e->xdestroywindow;
 
 	DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window);
 
-	if ((win = find_window(ev->window)) != NULL) {
-		/* find a window to focus */
-		ws = win->ws;
-		wl = &ws->winlist;
-		if (ws->focus == win) {
-			if (TAILQ_FIRST(wl) == win)
-				winfocus = TAILQ_NEXT(win, entry);
-			else {
-				winfocus = TAILQ_PREV(ws->focus, ws_win_list, entry);
-				if (winfocus == NULL)
-					winfocus = TAILQ_LAST(wl, ws_win_list);
-			}
-		}
-
-		unmanage_window(win);
-		stack();
-		if (winfocus)
-			focus_win(winfocus);
+	if ((win = find_window(ev->window)) == NULL) {
+		if ((win = find_unmanaged_window(ev->window)) == NULL)
+			return;
+		free_window(win);
+		return;
 	}
+
+	/* make sure we focus on something */
+	win->floating = 0;
+
+	unmanage_window(win);
+	stack();
+	free_window(win);
 }
 
 void
 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:
+		if (QLength(display)) {
+			DNPRINTF(SWM_D_EVENT, "ignore enternotify %d\n",
+			    QLength(display));
+			return;
+		}
+		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
+	 *
+	 * making this code an option would enable a follow mouse for focus
+	 * feature
+	 */
 
-	DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window);
-
-	if (ignore_enter) {
-		/* eat event(r) to prevent autofocus */
-		ignore_enter--;
+	/*
+	 * state is set when we are switching workspaces and focus is set when
+	 * the window or a subwindow already has focus (occurs during restart).
+	 *
+	 * Only honor the focus flag if last_focus_event is not FocusOut,
+	 * this allows scrotwm to continue to control focus when another
+	 * program is also playing with it.
+	 */
+	if (ev->state || (ev->focus && last_focus_event != FocusOut)) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: focus\n");
 		return;
 	}
+
 	/*
 	 * happens when a window is created or destroyed and the border
-	 * crosses the mouse pointer
+	 * crosses the mouse pointer and when switching ws
+	 *
+	 * we need the subwindow test to see if we came from root in order
+	 * to give focus to floaters
 	 */
-	if (QLength(display))
+	if (ev->mode == NotifyNormal && ev->detail == NotifyVirtual &&
+	    ev->subwindow == 0) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: NotifyVirtual\n");
 		return;
+	}
 
-	if ((win = find_window(ev->window)) != NULL)
-		focus_win(win);
+	/* this window already has focus */
+	if (ev->mode == NotifyNormal && ev->detail == NotifyInferior) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win has focus\n");
+		return;
+	}
+
+	/* this window is being deleted or moved to another ws */
+	if (XCheckTypedWindowEvent(display, ev->window, ConfigureNotify,
+	    &cne) == True) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: configurenotify\n");
+		XPutBackEvent(display, &cne);
+		return;
+	}
+
+	if ((win = find_window(ev->window)) == NULL) {
+		DNPRINTF(SWM_D_EVENT, "ignoring enternotify: win == NULL\n");
+		return;
+	}
+
+	/*
+	 * In fullstack kill all enters unless they come from a different ws
+	 * (i.e. another region) or focus has been grabbed externally.
+	 */
+	if (win->ws->cur_layout->flags & SWM_L_FOCUSPREV &&
+	    last_focus_event != FocusOut) {
+		XGetInputFocus(display, &focus_return, &revert_to_return);
+		if ((w = find_window(focus_return)) == NULL ||
+		    w->ws == win->ws) {
+			DNPRINTF(SWM_D_EVENT, "ignoring event: fullstack\n");
+			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);
 }
 
+/* lets us use one switch statement for arbitrary mode/detail combinations */
+#define MERGE_MEMBERS(a,b)	(((a & 0xffff) << 16) | (b & 0xffff))
+
 void
-focusin(XEvent *e)
+focusevent(XEvent *e)
 {
-	DNPRINTF(SWM_D_EVENT, "focusin: window: %lu\n", e->xfocus.window);
+#if 0
+	struct ws_win		*win;
+	u_int32_t		mode_detail;
+	XFocusChangeEvent	*ev = &e->xfocus;
+
+	DNPRINTF(SWM_D_EVENT, "focusevent: %s window: %lu mode %d detail %d\n",
+	    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);
+
+	switch (mode_detail) {
+	/* synergy client focus operations */
+	case MERGE_MEMBERS(NotifyNormal, NotifyNonlinear):
+	case MERGE_MEMBERS(NotifyNormal, NotifyNonlinearVirtual):
+
+	/* synergy server focus operations */
+	case MERGE_MEMBERS(NotifyWhileGrabbed, NotifyNonlinear):
+
+	/* Entering applications like rdesktop that mangle the pointer */
+	case MERGE_MEMBERS(NotifyNormal, NotifyPointer):
+
+		if ((win = find_window(e->xfocus.window)) != NULL && win->ws->r)
+			XSetWindowBorder(display, win->id,
+			    win->ws->r->s->c[ev->type == FocusIn ?
+			    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
-focusout(XEvent *e)
+mapnotify(XEvent *e)
 {
-	DNPRINTF(SWM_D_EVENT, "focusout: window: %lu\n", e->xfocus.window);
+	struct ws_win		*win;
+	XMapEvent		*ev = &e->xmap;
+
+	DNPRINTF(SWM_D_EVENT, "mapnotify: window: %lu\n", ev->window);
+
+	win = manage_window(ev->window);
+	if (win)
+		set_win_state(win, NormalState);
 }
 
 void
@@ -3507,8 +4350,6 @@ mappingnotify(XEvent *e)
 {
 	XMappingEvent		*ev = &e->xmapping;
 
-	DNPRINTF(SWM_D_EVENT, "mappingnotify: window: %lu\n", ev->window);
-
 	XRefreshKeyboardMapping(ev);
 	if (ev->request == MappingKeyboard)
 		grabkeys();
@@ -3519,9 +4360,8 @@ maprequest(XEvent *e)
 {
 	struct ws_win		*win;
 	struct swm_region	*r;
-
-	XMapRequestEvent	*ev = &e->xmaprequest;
 	XWindowAttributes	wa;
+	XMapRequestEvent	*ev = &e->xmaprequest;
 
 	DNPRINTF(SWM_D_EVENT, "maprequest: window: %lu\n",
 	    e->xmaprequest.window);
@@ -3531,15 +4371,16 @@ maprequest(XEvent *e)
 	if (wa.override_redirect)
 		return;
 
-	manage_window(e->xmaprequest.window);
+	win = manage_window(e->xmaprequest.window);
+	if (win == NULL)
+		return; /* can't happen */
 
 	stack();
 
 	/* make new win focused */
-	win = find_window(ev->window);
 	r = root_to_region(win->wa.root);
 	if (win->ws == r->ws)
-		focus_win(win);
+		focus_magic(win, SWM_F_GENERIC);
 }
 
 void
@@ -3580,7 +4421,19 @@ propertynotify(XEvent *e)
 void
 unmapnotify(XEvent *e)
 {
+	struct ws_win		*win;
+
 	DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
+
+	/* determine if we need to help unmanage this window */
+	win = find_window(e->xunmap.window);
+	if (win == NULL)
+		return;
+
+	if (getstate(e->xunmap.window) == NormalState) {
+		unmanage_window(win);
+		stack();
+	}
 }
 
 void
@@ -3630,25 +4483,6 @@ active_wm(void)
 	return (0);
 }
 
-long
-getstate(Window w)
-{
-	int			format, status;
-	long			result = -1;
-	unsigned char		*p = NULL;
-	unsigned long		n, extra;
-	Atom			real;
-
-	status = XGetWindowProperty(display, w, astate, 0L, 2L, False, astate,
-	    &real, &format, &n, &extra, (unsigned char **)&p);
-	if (status != Success)
-		return (-1);
-	if (n != 0)
-		result = *((long *)p);
-	XFree(p);
-	return (result);
-}
-
 void
 new_region(struct swm_screen *s, int x, int y, int w, int h)
 {
@@ -3668,6 +4502,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);
@@ -3714,6 +4551,7 @@ 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;
 	TAILQ_INSERT_TAIL(&s->rl, r, entry);
 }
@@ -3735,7 +4573,7 @@ scan_xrandr(int i)
 
 	/* remove any old regions */
 	while ((r = TAILQ_FIRST(&screens[i].rl)) != NULL) {
-		r->ws->r = NULL;
+		r->ws->old_r = r->ws->r = NULL;
 		XDestroyWindow(display, r->bar_window);
 		TAILQ_REMOVE(&screens[i].rl, r, entry);
 		TAILQ_INSERT_TAIL(&screens[i].orl, r, entry);
@@ -3782,7 +4620,6 @@ void
 screenchange(XEvent *e) {
 	XRRScreenChangeNotifyEvent	*xe = (XRRScreenChangeNotifyEvent *)e;
 	struct swm_region		*r;
-	struct ws_win			*win;
 	int				i;
 
 	DNPRINTF(SWM_D_EVENT, "screenchange: %lu\n", xe->root);
@@ -3800,11 +4637,6 @@ screenchange(XEvent *e) {
 	/* brute force for now, just re-enumerate the regions */
 	scan_xrandr(i);
 
-	/* hide any windows that went away */
-	TAILQ_FOREACH(r, &screens[i].rl, entry)
-		TAILQ_FOREACH(win, &r->ws->winlist, entry)
-			XUnmapWindow(display, win->id);
-
 	/* add bars to all regions */
 	for (i = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
@@ -3822,7 +4654,7 @@ setup_screens(void)
 	int			errorbase, major, minor;
 	struct workspace	*ws;
 	int			ws_idx_atom;
-
+	long			state, manage;
 
 	if ((screens = calloc(ScreenCount(display),
 	     sizeof(struct swm_screen))) == NULL)
@@ -3852,15 +4684,20 @@ 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++) {
 			ws = &screens[i].ws[j];
 			ws->idx = j;
-			ws->restack = 1;
 			ws->focus = NULL;
 			ws->r = NULL;
+			ws->old_r = NULL;
 			TAILQ_INIT(&ws->winlist);
+			TAILQ_INIT(&ws->unmanagedlist);
 
 			for (k = 0; layouts[k].l_stack != NULL; k++)
 				if (layouts[k].l_config != NULL)
@@ -3881,24 +4718,26 @@ setup_screens(void)
 		/* attach windows to a region */
 		/* normal windows */
 		for (j = 0; j < no; j++) {
-                        XGetWindowAttributes(display, wins[j], &wa);
 			if (!XGetWindowAttributes(display, wins[j], &wa) ||
 			    wa.override_redirect ||
 			    XGetTransientForHint(display, wins[j], &d1))
 				continue;
 
-			if (wa.map_state == IsViewable ||
-			    getstate(wins[j]) == NormalState)
+			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))
+			if (!XGetWindowAttributes(display, wins[j], &wa) ||
+			    wa.override_redirect)
 				continue;
 
+			state = getstate(wins[j]);
+			manage = state == IconicState;
 			if (XGetTransientForHint(display, wins[j], &d1) &&
-			    (wa.map_state == IsViewable || getstate(wins[j]) ==
-			    NormalState))
+			    manage)
 				manage_window(wins[j]);
                 }
                 if (wins) {
@@ -3907,6 +4746,7 @@ setup_screens(void)
 		}
 	}
 }
+
 void
 setup_globals(void)
 {
@@ -3921,6 +4761,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
@@ -3949,6 +4791,8 @@ main(int argc, char *argv[])
 	struct passwd		*pwd;
 	struct swm_region	*r, *rr;
 	struct ws_win		*winfocus = NULL;
+	struct timeval		tv;
+	union arg		a;
 	char			conf[PATH_MAX], *cfile = NULL;
 	struct stat		sb;
 	XEvent			e;
@@ -3977,6 +4821,7 @@ main(int argc, char *argv[])
 	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);
 
 	/* look for local and global conf file */
 	pwd = getpwuid(getuid());
@@ -4014,6 +4859,8 @@ main(int argc, char *argv[])
 	/* set some values to work around bad programs */
 	workaround();
 
+	unfocus_all();
+
 	grabkeys();
 	stack();
 
@@ -4047,21 +4894,29 @@ main(int argc, char *argv[])
 
 		/* if we are being restarted go focus on first window */
 		if (winfocus) {
-			rr = TAILQ_FIRST(&screens[0].rl);
+			rr = winfocus->ws->r;
+			if (rr == NULL) {
+				/* not a visible window */
+				winfocus = NULL;
+				continue;
+			}
 			/* move pointer to first screen if multi screen */
 			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);
 
-			focus_win(winfocus);
+			a.id = SWM_ARG_ID_FOCUSCUR;
+			focus(rr, &a);
 			winfocus = NULL;
 			continue;
 		}
 
 		FD_ZERO(&rd);
 		FD_SET(xfd, &rd);
-		if (select(xfd + 1, &rd, NULL, NULL, NULL) == -1)
+		tv.tv_sec = 1;
+		tv.tv_usec = 0;
+		if (select(xfd + 1, &rd, NULL, NULL, &tv) == -1)
 			if (errno != EINTR)
 				DNPRINTF(SWM_D_MISC, "select failed");
 		if (running == 0)
@@ -4073,7 +4928,7 @@ main(int argc, char *argv[])
 	}
 done:
 	bar_extra_stop();
-
+	XFreeGC(display, bar_gc);
 	XCloseDisplay(display);
 
 	return (0);