X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=067806b64da2581e332852f94cc28cad90517515;hb=803efec3fdf794b4c3e923738a655c896d39cc6c;hp=3f1566ae6f46fdd72f182486b837fbfa8754a87f;hpb=841e741913acb91111fabae2f93b7257e845722e;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index 3f1566a..067806b 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -52,7 +52,7 @@
 
 static const char	*cvstag = "$scrotwm$";
 
-#define	SWM_VERSION	"1.0"
+#define	SWM_VERSION	"0.9.18"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -148,6 +148,7 @@ 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)
 
 #ifndef SWM_LIB
 #define SWM_LIB			"/usr/local/lib/libswmhack.so"
@@ -165,7 +166,6 @@ int			other_wm;
 int			ss_enabled = 0;
 int			xrandr_support;
 int			xrandr_eventbase;
-int			ignore_enter = 0;
 unsigned int		numlockmask = 0;
 Display			*display;
 
@@ -307,6 +307,7 @@ enum keyfuncid {
 	kf_spawn_lock,
 	kf_spawn_initscr,
 	kf_spawn_custom,
+	kf_dumpwins,
 	kf_invalid
 };
 
@@ -318,9 +319,12 @@ 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 *);
@@ -334,8 +338,8 @@ struct layout {
 	{ vertical_stack,	vertical_config,	0,	"[|]" },
 	{ horizontal_stack,	horizontal_config,	0,	"[-]" },
 	{ max_stack,		NULL,
-	  SWM_L_FOCUSPREV | SWM_L_MAPONFOCUS,			"[ ]"},
-	{ NULL,			NULL,			0},
+	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			"[ ]"},
+	{ NULL,			NULL,			0,	NULL },
 };
 
 #define SWM_H_SLICE		(32)
@@ -344,13 +348,13 @@ struct layout {
 /* 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 {
@@ -367,9 +371,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;
@@ -390,30 +394,35 @@ 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_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;
@@ -546,8 +555,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 *);
@@ -821,7 +870,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");
 
@@ -835,9 +884,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 */
@@ -925,40 +971,18 @@ bar_setup(struct swm_region *r)
 	bar_refresh();
 }
 
-Bool
-set_win_notify_cb(Display *d, XEvent *e, char *arg)
-{
-	struct ws_win		*win = (struct ws_win *)arg;
-
-	if (win && win->id == e->xany.window && e->xany.type == PropertyNotify)
-			return (True);
-	return (False);
-}
-
 void
 set_win_state(struct ws_win *win, long state)
 {
 	long			data[] = {state, None};
-	XEvent			ev;
-	XWindowAttributes	wa;
 
 	DNPRINTF(SWM_D_EVENT, "set_win_state: window: %lu\n", win->id);
 
 	if (win == NULL)
 		return;
-	/* make sure we drain everything */
-	XSync(display, True);
-
-	/* make sure we still exist too */
-	if (XGetWindowAttributes(display, win->id, &wa) == BadWindow)
-		return;
 
 	XChangeProperty(display, win->id, astate, astate, 32, PropModeReplace,
 	    (unsigned char *)data, 2);
-
-	/* wait for completion of XChangeProperty */
-	while (XCheckIfEvent(display, &ev, set_win_notify_cb, (char *)win))
-		;
 }
 
 long
@@ -997,6 +1021,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;
@@ -1008,12 +1035,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;
@@ -1033,21 +1086,6 @@ count_win(struct workspace *ws, int count_transient)
 {
 	struct ws_win		*win;
 	int			count = 0;
-	int			state;
-
-	/*
-	 * Under stress conditions windows sometimes do not get removed from
-	 * the managed list quickly enough.  Use a very large hammer to get rid
-	 * of them.  A smaller hammer would be nice.
-	 */
-	TAILQ_FOREACH(win, &ws->winlist, entry) {
-		state = getstate(win->id);
-		if (state == -1) {
-			DNPRINTF(SWM_D_MISC, "count_win:removing: %lu\n",
-			    win->id);
-			unmanage_window(win);
-		}
-	}
 
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
 		if (count_transient == 0 && win->floating)
@@ -1068,42 +1106,19 @@ quit(struct swm_region *r, union arg *args)
 	running = 0;
 }
 
-Bool
-unmap_window_cb(Display *d, XEvent *e, char *arg)
-{
-	struct ws_win		*win = (struct ws_win *)arg;
-
-	if (win && win->id == e->xany.window && e->xany.type == UnmapNotify)
-			return (True);
-	return (False);
-}
-
 void
 unmap_window(struct ws_win *win)
 {
-	XEvent			ev;
-	XWindowAttributes	wa;
-
 	if (win == NULL)
 		return;
 
-	/* make sure we still exist too */
-	if (XGetWindowAttributes(display, win->id, &wa) == BadWindow)
-		return;
-
 	/* don't unmap again */
-	if (wa.map_state == IsUnmapped && getstate(win->id) == IconicState)
+	if (getstate(win->id) == IconicState)
 		return;
 
-	/* java shits itself when windows are set to iconic state */
-	if (win->java == 0)
-		set_win_state(win, IconicState);
+	set_win_state(win, IconicState);
 
 	XUnmapWindow(display, win->id);
-
-	/* make sure we wait for XUnmapWindow completion */
-	while (XCheckIfEvent(display, &ev, unmap_window_cb, (char *)win))
-		;
 }
 
 void
@@ -1123,6 +1138,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;
@@ -1194,6 +1212,21 @@ root_to_region(Window root)
 }
 
 struct ws_win *
+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;
@@ -1257,36 +1290,117 @@ 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)
 {
 	if (win == NULL)
 		return;
+	if (win->ws == NULL)
+		return;
+
+	if (validate_ws(win->ws))
+		abort();
 
 	if (win->ws->r == NULL)
 		return;
 
+	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;
+	}
+
 	grabbuttons(win, 0);
 	XSetWindowBorder(display, win->id,
 	    win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
 }
 
 void
-unfocus_all(void)
+unfocus_all_except(struct ws_win *except)
 {
 	struct ws_win		*win;
 	int			i, j;
 
-	DNPRINTF(SWM_D_FOCUS, "unfocus_all:\n");
+	DNPRINTF(SWM_D_FOCUS, "unfocus_all_except: id: %lu\n", except->id);
 
 	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);
+				if (win != except)
+					unfocus_win(win);
 }
 
 void
@@ -1296,17 +1410,32 @@ focus_win(struct ws_win *win)
 
 	if (win == NULL)
 		return;
+	if (win->ws == NULL)
+		return;
+
+	if (validate_ws(win->ws))
+		abort();
+	if (validate_win(win)) {
+		kill_refs(win);
+		return;
+	}
 
 	/* use big hammer to make sure it works under all use cases */
-	unfocus_all();
+	unfocus_all_except(win);
+
+	if (validate_win(win)) {
+		kill_refs(win);
+		return;
+	}
+
 	win->ws->focus = win;
 
 	if (win->ws->r != NULL) {
-		XSetWindowBorder(display, win->id,
-		    win->ws->r->s->c[SWM_S_COLOR_FOCUS].color);
 		grabbuttons(win, 1);
 		if (win->ws->cur_layout->flags & SWM_L_MAPONFOCUS)
 			XMapRaised(display, win->id);
+		XSetWindowBorder(display, win->id,
+		    win->ws->r->s->c[SWM_S_COLOR_FOCUS].color);
 		if (win->java == 0)
 			XSetInputFocus(display, win->id,
 			    RevertToPointerRoot, CurrentTime);
@@ -1318,8 +1447,12 @@ switchws(struct swm_region *r, union arg *args)
 {
 	int			wsid = args->id;
 	struct swm_region	*this_r, *other_r;
-	struct ws_win		*win, *winfocus = NULL, *parent = 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;
@@ -1329,34 +1462,17 @@ 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 */
 		if (old_ws->r != NULL)
 			old_ws->old_r = old_ws->r;
 		old_ws->r = NULL;
-		old_ws->restack = 1;
-
-		/*
-		 * Map new windows first if they were here before
-		 * to minimize ugly blinking.
-		 */
-		if (new_ws->old_r == this_r)
-			TAILQ_FOREACH(win, &new_ws->winlist, entry)
-				if (!(win->ws->cur_layout->flags &
-				    SWM_L_MAPONFOCUS))
-					XMapRaised(display, win->id);
 
 		TAILQ_FOREACH(win, &old_ws->winlist, entry)
 			unmap_window(win);
@@ -1367,19 +1483,9 @@ switchws(struct swm_region *r, union arg *args)
 	this_r->ws = new_ws;
 	new_ws->r = this_r;
 
-	ignore_enter = 1;
 	stack();
-	if (winfocus) {
-		/* make sure we see the parent window */
-		if (winfocus->transient) {
-			parent = find_window(winfocus->transient);
-			if (parent)
-				focus_win(parent);
-		}
-
-		focus_win(winfocus);
-	}
-	ignore_enter = 0;
+	a.id = SWM_ARG_ID_FOCUSCUR;
+	focus(new_ws->r, &a);
 	bar_update();
 }
 
@@ -1425,8 +1531,7 @@ void
 cyclescr(struct swm_region *r, union arg *args)
 {
 	struct swm_region	*rr = NULL;
-	struct workspace	*ws = NULL;
-	struct ws_win		*winfocus = NULL;
+	union arg		a;
 	int			i, x, y;
 
 	/* do nothing if we don't have more than one screen */
@@ -1451,25 +1556,20 @@ cyclescr(struct swm_region *r, union arg *args)
 	if (rr == NULL)
 		return;
 
-	ws = rr->ws;
-	winfocus = ws->focus;
-	if (winfocus == NULL)
-		winfocus = ws->focus_prev;
-	if (winfocus) {
-		/* use window coordinates */
-		x = winfocus->g.x + 1;
-		y = winfocus->g.y + 1;
-	} else {
-		/* use region coordinates */
-		x = rr->g.x + 1;
-		y = rr->g.y + 1 + bar_enabled ? bar_height : 0;
-	}
-
-	unfocus_all();
-	XSetInputFocus(display, PointerRoot, RevertToPointerRoot, CurrentTime);
+	/* 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);
 
-	focus_win(winfocus);
+	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
@@ -1518,6 +1618,8 @@ 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);
@@ -1529,29 +1631,101 @@ swapwin(struct swm_region *r, union arg *args)
 		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 */
+	/* XXX needs more love */
+	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;
+		goto done;
+	}
+
+	if (cur_focus == win)
+		winfocus = TAILQ_PREV(win, ws_win_list, entry);
+	if (winfocus == NULL)
+		winfocus = TAILQ_FIRST(wl);
+	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);
@@ -1567,8 +1741,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:
@@ -1578,14 +1750,15 @@ focus(struct swm_region *r, union arg *args)
 	if (winfocus == winlostfocus || winfocus == NULL)
 		return;
 
-	focus_win(winfocus);
+	focus_magic(winfocus, SWM_F_GENERIC);
 }
 
 void
 cycle_layout(struct swm_region *r, union arg *args)
 {
 	struct workspace	*ws = r->ws;
-	struct ws_win		*winfocus, *parent = NULL;
+	struct ws_win		*winfocus;
+	union arg		a;
 
 	DNPRINTF(SWM_D_EVENT, "cycle_layout: workspace: %d\n", ws->idx);
 
@@ -1595,17 +1768,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();
-	/* make sure we see the parent window */
-	if (winfocus) {
-		if (winfocus->transient)
-			parent = find_window(winfocus->transient);
-		if (parent)
-			focus_win(parent);
-		focus_win(winfocus);
-	}
-	ignore_enter = 0;
+	a.id = SWM_ARG_ID_FOCUSCUR;
+	focus(r, &a);
+	bar_update();
 }
 
 void
@@ -1645,8 +1811,6 @@ stack(void) {
 				g.y += bar_height;
 				g.h -= bar_height;
 			}
-
-			r->ws->restack = 0;
 			r->ws->cur_layout->l_stack(r->ws, &g);
 		}
 	}
@@ -1665,8 +1829,8 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 
 	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)))
+	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;
@@ -1685,13 +1849,21 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 	}
 
 	/* adjust for region */
-	wc.x += r->g.x;
-	wc.y += r->g.y;
+	if (wc.x < r->g.x)
+		wc.x += r->g.x;
+	if (wc.y < r->g.y)
+		wc.y += r->g.y;
 
-	DNPRINTF(SWM_D_STACK, "stack_floater: win %lu x %d y %d w %d h %d\n",
+	win->g.x = wc.x;
+	win->g.y = wc.y;
+	win->g.w = wc.width;
+	win->g.h = wc.height;
+
+	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);
 }
 
 /*
@@ -1738,7 +1910,7 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 	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",
@@ -1859,20 +2031,32 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 
 		bzero(&wc, sizeof wc);
 		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;
+			}
+		}
+		if (reconfigure) {
+			adjust_font(win);
+			mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
+			XConfigureWindow(display, win->id, mask, &wc);
+			configreq_win(win);
 		}
-		adjust_font(win);
-		mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
-		XConfigureWindow(display, win->id, mask, &wc);
 		XMapRaised(display, win->id);
 
 		last_h = win_g.h;
@@ -1991,7 +2175,7 @@ max_stack(struct workspace *ws, struct swm_geometry *g)
 {
 	XWindowChanges		wc;
 	struct swm_geometry	gg = *g;
-	struct ws_win		*win, *wintrans = NULL;
+	struct ws_win		*win, *wintrans = NULL, *parent = NULL;
 	unsigned int		mask;
 	int			winno;
 
@@ -2005,9 +2189,15 @@ max_stack(struct workspace *ws, struct swm_geometry *g)
 		return;
 
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
-		if (win->transient != 0) {
+		if (win->transient) {
 			wintrans = win;
-		} else {
+			parent = find_window(win->transient);
+			continue;
+		}
+
+		/* 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;
@@ -2016,18 +2206,20 @@ max_stack(struct workspace *ws, struct swm_geometry *g)
 			win->g.h = wc.height = gg.h;
 			mask = CWX | CWY | CWWidth | CWHeight | CWBorderWidth;
 			XConfigureWindow(display, win->id, mask, &wc);
-
-			/* unmap only if we don't have multi screen */
-			if (win != ws->focus)
-				if (!(ScreenCount(display) > 1 || outputs > 1))
-					unmap_window(win);
+			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_win(wintrans); /* override */
+		focus_magic(wintrans, SWM_F_TRANSIENT);
 	}
 }
 
@@ -2035,10 +2227,11 @@ void
 send_to_ws(struct swm_region *r, union arg *args)
 {
 	int			wsid = args->id;
-	struct ws_win		*win = win, *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;
@@ -2046,26 +2239,16 @@ send_to_ws(struct swm_region *r, union arg *args)
 		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(win, 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 we multi screen */
-	if (winfocus == NULL)
-		if (ScreenCount(display) > 1 || outputs > 1)
-			winfocus = win;
-
+	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);
@@ -2080,15 +2263,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();
-	if (winfocus)
-		focus_win(winfocus);
 }
 
 void
@@ -2110,6 +2285,7 @@ void
 floating_toggle(struct swm_region *r, union arg *args)
 {
 	struct ws_win	*win = r->ws->focus;
+	union arg	a;
 
 	if (win == NULL)
 		return;
@@ -2117,7 +2293,8 @@ floating_toggle(struct swm_region *r, union arg *args)
 	win->floating = !win->floating;
 	win->manual = 0;
 	stack();
-	focus_win(win);
+	a.id = SWM_ARG_ID_FOCUSCUR;
+	focus(win->ws->r, &a);
 }
 
 void
@@ -2143,7 +2320,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
@@ -2151,8 +2328,9 @@ resize(struct ws_win *win, union arg *args)
 {
 	XEvent			ev;
 	Time			time = 0;
+	struct swm_region	*r = win->ws->r;
 
-	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))
@@ -2172,6 +2350,14 @@ 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.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)
+				continue;
+
 			if (ev.xmotion.x <= 1)
 				ev.xmotion.x = 1;
 			if (ev.xmotion.y <= 1)
@@ -2217,7 +2403,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
@@ -2226,8 +2412,9 @@ 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 %d\n",
+	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
 
 	if (win->floating == 0) {
@@ -2250,6 +2437,14 @@ move(struct ws_win *win, union arg *args)
 			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)
+				continue;
+
 			win->g.x = ev.xmotion.x_root;
 			win->g.y = ev.xmotion.y_root;
 
@@ -2344,6 +2539,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 {
@@ -2866,6 +3062,9 @@ 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
@@ -3323,12 +3522,22 @@ 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 = 0;
 	struct workspace	*ws;
-	struct ws_win		*win, *ww, *parent;
+	struct ws_win		*win, *ww;
 	int			format, i, ws_idx, n, border_me = 0;
 	unsigned long		nitems, bytes;
 	Atom			ws_idx_atom = 0, type;
@@ -3340,7 +3549,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");
@@ -3355,11 +3575,9 @@ manage_window(Window id)
 	XGetTransientForHint(display, id, &trans);
 	if (trans) {
 		win->transient = trans;
-		parent = find_window(win->transient);
-		if (parent)
-			parent->child_trans = win;
-		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)) {
@@ -3429,23 +3647,25 @@ manage_window(Window id)
 		    win->ch.res_class, win->ch.res_name);
 
 		/* java is retarded so treat it special */
-		if (strstr(win->ch.res_name, "sun-awt"))
+		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;
 			}
 		}
 	}
 
-	if (win->java && win->transient) {
-	}
 	/* alter window position if quirky */
 	if (win->quirks & SWM_Q_ANYWHERE) {
 		win->manual = 1; /* don't center the quirky windows */
@@ -3476,6 +3696,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 |
@@ -3491,9 +3712,34 @@ manage_window(Window id)
 }
 
 void
+free_window(struct ws_win *win)
+{
+	DNPRINTF(SWM_D_MISC, "free_window:  %lu\n", win->id);
+
+	if (win == NULL)
+		return;
+
+	/* 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 workspace	*ws;
 	struct ws_win		*parent;
 
 	if (win == NULL)
@@ -3507,19 +3753,22 @@ unmanage_window(struct ws_win *win)
 			parent->child_trans = NULL;
 	}
 
-	ws = win->ws;
+	focus_prev(win);
 	TAILQ_REMOVE(&win->ws->winlist, win, entry);
-	if (win->ch.res_class)
-		XFree(win->ch.res_class);
-	if (win->ch.res_name)
-		XFree(win->ch.res_name);
-	free(win);
+	TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
+
+	kill_refs(win);
 }
 
 void
-focus_magic(struct ws_win *win)
+focus_magic(struct ws_win *win, int do_trans)
 {
-	if (win->child_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);
@@ -3575,10 +3824,9 @@ keypress(XEvent *e)
 void
 buttonpress(XEvent *e)
 {
-	XButtonPressedEvent	*ev = &e->xbutton;
-
 	struct ws_win		*win;
 	int			i, action;
+	XButtonPressedEvent	*ev = &e->xbutton;
 
 	DNPRINTF(SWM_D_EVENT, "buttonpress: window: %lu\n", ev->window);
 
@@ -3586,7 +3834,7 @@ buttonpress(XEvent *e)
 	if ((win = find_window(ev->window)) == NULL)
 		return;
 
-	focus_magic(win);
+	focus_magic(win, SWM_F_TRANSIENT);
 	action = client_click;
 
 	for (i = 0; i < LENGTH(buttons); i++)
@@ -3605,7 +3853,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",
@@ -3631,27 +3880,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);
 	}
 }
 
@@ -3664,12 +3894,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();
 	}
@@ -3678,51 +3906,21 @@ 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 we are transient give focus to parent */
-		if (win->transient)
-			winfocus = find_window(win->transient);
-		else if (ws->focus == win) {
-			/* if in max_stack try harder */
-			if (ws->cur_layout->flags & SWM_L_FOCUSPREV) {
-				if (win != ws->focus_prev)
-					winfocus = ws->focus_prev;
-				else if (win != ws->focus)
-					winfocus = ws->focus;
-			}
-
-			/* fallback and normal handling */
-			if (winfocus == NULL) {
-				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);
-
-		ignore_enter = 1;
-		stack();
-		if (winfocus)
-			focus_win(winfocus);
-		ignore_enter = 0;
+	if ((win = find_window(ev->window)) == NULL) {
+		if ((win = find_unmanaged_window(ev->window)) == NULL)
+			return;
+		free_window(win);
+		return;
 	}
+
+	unmanage_window(win);
+	stack();
+	free_window(win);
 }
 
 void
@@ -3733,11 +3931,6 @@ enternotify(XEvent *e)
 
 	DNPRINTF(SWM_D_EVENT, "enternotify: window: %lu\n", ev->window);
 
-	if (ignore_enter) {
-		/* eat event(r) to prevent autofocus */
-		ignore_enter = 0;
-		return;
-	}
 	/*
 	 * happens when a window is created or destroyed and the border
 	 * crosses the mouse pointer
@@ -3748,7 +3941,7 @@ enternotify(XEvent *e)
 	if ((win = find_window(ev->window)) == NULL)
 		return;
 
-	focus_magic(win);
+	focus_magic(win, SWM_F_TRANSIENT);
 }
 
 void
@@ -3771,7 +3964,7 @@ mapnotify(XEvent *e)
 
 	DNPRINTF(SWM_D_EVENT, "mapnotify: window: %lu\n", ev->window);
 
-	win = find_window(ev->window);
+	win = manage_window(ev->window);
 	if (win)
 		set_win_state(win, NormalState);
 }
@@ -3791,9 +3984,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);
@@ -3807,14 +3999,12 @@ maprequest(XEvent *e)
 	if (win == NULL)
 		return; /* can't happen */
 
-	ignore_enter = 1;
 	stack();
-	ignore_enter = 0;
 
 	/* make new win focused */
 	r = root_to_region(win->wa.root);
 	if (win->ws == r->ws)
-		focus_win(win);
+		focus_magic(win, SWM_F_GENERIC);
 }
 
 void
@@ -3855,8 +4045,7 @@ propertynotify(XEvent *e)
 void
 unmapnotify(XEvent *e)
 {
-	struct ws_win		*win, *winfocus = NULL;
-	struct workspace	*ws;
+	struct ws_win		*win;
 
 	DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
 
@@ -3865,47 +4054,16 @@ unmapnotify(XEvent *e)
 	if (win == NULL)
 		return;
 
-	/* java can not deal with this heuristic */
-	if (win->java)
+	/*
+	 * 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) {
-		/*
-		 * this window does not have a destroy event but but it is no
-		 * longer visible due to the app unmapping it so unmanage it
-		 */
-		ws = win->ws;
-		/* if we are max_stack try harder to focus on something */
-		if (ws->cur_layout->flags & SWM_L_FOCUSPREV) {
-			if (win->transient)
-				winfocus = find_window(win->transient);
-			else if (win != ws->focus_prev)
-				winfocus = ws->focus_prev;
-			else if (win != ws->focus)
-				winfocus = ws->focus;
-		}
-
-		/* normal and fallback if haven't found anything to focus on */
-		if (winfocus == NULL) {
-			winfocus = TAILQ_PREV(win, ws_win_list, entry);
-			if (TAILQ_FIRST(&ws->winlist) == win)
-				winfocus = TAILQ_NEXT(win, entry);
-			else {
-				if (ws->focus)
-					winfocus = TAILQ_PREV(ws->focus,
-					    ws_win_list, entry);
-				if (winfocus == NULL)
-					winfocus = TAILQ_LAST(&ws->winlist,
-					    ws_win_list);
-			}
-		}
-
-		/* trash window and refocus */
 		unmanage_window(win);
-		ignore_enter = 1;
 		stack();
-		focus_win(winfocus);
-		ignore_enter = 0;
 	}
 }
 
@@ -4158,11 +4316,11 @@ setup_screens(void)
 		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)
@@ -4183,24 +4341,24 @@ 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;
 
 			state = getstate(wins[j]);
-			manage = state == NormalState || state == IconicState;
+			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 == NormalState || state == IconicState;
+			manage = state == IconicState;
 			if (XGetTransientForHint(display, wins[j], &d1) &&
 			    manage)
 				manage_window(wins[j]);
@@ -4254,6 +4412,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;
@@ -4353,21 +4513,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)