X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=a1f1c0a9f9d5aca80a2db7a2aaa018ba28737369;hb=2a8d7bafe32519fac1ca81604a625199f21b3ad4;hp=a2997cc167b4776114c2d2b2ecf6c5f2870de599;hpb=af851bfc41facb5b4632d8b9938df2813be61684;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index a2997cc..a1f1c0a 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -51,9 +51,10 @@
  * DEALINGS IN THE SOFTWARE.
  */
 
-static const char	*cvstag = "$scrotwm$";
+static const char	*cvstag =
+    "$scrotwm$";
 
-#define	SWM_VERSION	"0.9.30"
+#define	SWM_VERSION	"0.9.32"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -287,9 +288,19 @@ struct ws_win {
 	XWindowAttributes	wa;
 	XSizeHints		sh;
 	XClassHint		ch;
+	XWMHints		*hints;
 };
 TAILQ_HEAD(ws_win_list, ws_win);
 
+/* pid goo */
+struct pid_e {
+	TAILQ_ENTRY(pid_e)	entry;
+	long			pid;
+	int			ws;
+};
+TAILQ_HEAD(pid_list, pid_e);
+struct pid_list			pidlist = TAILQ_HEAD_INITIALIZER(pidlist);
+
 /* layout handlers */
 void	stack(void);
 void	vertical_config(struct workspace *, int);
@@ -317,12 +328,14 @@ struct layout {
 	{ vertical_stack,	vertical_config,	0,	"[|]" },
 	{ horizontal_stack,	horizontal_config,	0,	"[-]" },
 	{ max_stack,		NULL,
-	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			"[ ]"},
-	{ NULL,			NULL,			0,	NULL },
+	  SWM_L_MAPONFOCUS | SWM_L_FOCUSPREV,			"[ ]" },
+	{ NULL,			NULL,			0,	NULL  },
 };
 
-/* position of max_stack mode in the layouts array */
-#define SWM_MAX_STACK		2
+/* position of max_stack mode in the layouts array, index into layouts! */
+#define SWM_V_STACK		(0)
+#define SWM_H_STACK		(1)
+#define SWM_MAX_STACK		(2)
 
 #define SWM_H_SLICE		(32)
 #define SWM_V_SLICE		(32)
@@ -415,6 +428,7 @@ struct quirk {
 #define SWM_Q_ANYWHERE		(1<<2)	/* don't position this window */
 #define SWM_Q_XTERM_FONTADJ	(1<<3)	/* adjust xterm fonts when resizing */
 #define SWM_Q_FULLSCREEN	(1<<4)	/* remove border */
+#define SWM_Q_FOCUSPREV		(1<<5)	/* focus on caller */
 };
 int				quirks_size = 0, quirks_length = 0;
 struct quirk			*quirks = NULL;
@@ -554,7 +568,8 @@ setup_ewmh(void)
 		/* Report supported atoms */
 		XDeleteProperty(display, screens[i].root, sup_list);
 		for (j = 0; j < LENGTH(ewmh); j++)
-			XChangeProperty(display, screens[i].root, sup_list, XA_ATOM, 32,
+			XChangeProperty(display, screens[i].root,
+			    sup_list, XA_ATOM, 32,
 			    PropModeAppend, (unsigned char *)&ewmh[j].atom,1);
 	}
 }
@@ -740,7 +755,8 @@ ewmh_update_win_state(struct ws_win *win, long state, long action)
 			win->manual = (win->ewmh_flags & SWM_F_MANUAL) != 0;
 	if (state == ewmh[_NET_WM_STATE_FULLSCREEN].atom)
 		if (changed)
-			if (!ewmh_set_win_fullscreen(win, win->ewmh_flags & EWMH_F_FULLSCREEN))
+			if (!ewmh_set_win_fullscreen(win,
+			    win->ewmh_flags & EWMH_F_FULLSCREEN))
 				win->ewmh_flags = orig_flags; /* revert */
 
 	XDeleteProperty(display, win->id, ewmh[_NET_WM_STATE].atom);
@@ -783,8 +799,8 @@ ewmh_get_win_state(struct ws_win *win)
 	if (win->manual)
 		win->ewmh_flags |= SWM_F_MANUAL;
 
-	success = get_property(win->id, ewmh[_NET_WM_STATE].atom, (~0L), XA_ATOM,
-	    &n, (unsigned char **)&states);
+	success = get_property(win->id, ewmh[_NET_WM_STATE].atom,
+	    (~0L), XA_ATOM, &n, (unsigned char **)&states);
 
 	if (!success)
 		return;
@@ -1042,6 +1058,24 @@ sighdlr(int sig)
 	errno = saved_errno;
 }
 
+struct pid_e *
+find_pid(long pid)
+{
+	struct pid_e		*p = NULL;
+
+	DNPRINTF(SWM_D_MISC, "find_pid: %lu\n", pid);
+
+	if (pid == 0)
+		return (NULL);
+
+	TAILQ_FOREACH(p, &pidlist, entry) {
+		if (p->pid == pid)
+			return (p);
+	}
+
+	return (NULL);
+}
+
 unsigned long
 name_to_color(char *colorname)
 {
@@ -1107,7 +1141,8 @@ custom_region(char *val)
 	    y < 0 || y > DisplayHeight(display, sidx) ||
 	    w + x > DisplayWidth(display, sidx) ||
 	    h + y > DisplayHeight(display, sidx)) {
-		fprintf(stderr, "ignoring region %ux%u+%u+%u - not within screen boundaries "
+		fprintf(stderr, "ignoring region %ux%u+%u+%u "
+		    "- not within screen boundaries "
 		    "(%ux%u)\n", w, h, x, y,
 		    DisplayWidth(display, sidx), DisplayHeight(display, sidx));
 		return;
@@ -1360,12 +1395,14 @@ bar_setup(struct swm_region *r)
 	if (bar_fs == NULL)
 		errx(1, "couldn't create font structure");
 
-	bar_height = bar_fs->ascent + bar_fs->descent + 1 + 2 * bar_border_width;
+	bar_height = bar_fs->ascent + bar_fs->descent + 1 +
+	    2 * bar_border_width;
 	x = X(r);
 	y = bar_at_bottom ? (Y(r) + HEIGHT(r) - bar_height) : Y(r);
 
 	r->bar_window = XCreateSimpleWindow(display,
-	    r->s->root, x, y, WIDTH(r) - 2 * bar_border_width, bar_height - 2 * bar_border_width,
+	    r->s->root, x, y, WIDTH(r) - 2 * bar_border_width,
+	    bar_height - 2 * bar_border_width,
 	    bar_border_width, r->s->c[SWM_S_COLOR_BAR_BORDER].color,
 	    r->s->c[SWM_S_COLOR_BAR].color);
 	bar_gc = XCreateGC(display, r->bar_window, 0, &bar_gcv);
@@ -1381,6 +1418,18 @@ bar_setup(struct swm_region *r)
 }
 
 void
+drain_enter_notify(void)
+{
+	int			i = 0;
+	XEvent			cne;
+
+	while (XCheckMaskEvent(display, EnterWindowMask, &cne))
+		i++;
+
+	DNPRINTF(SWM_D_MISC, "drain_enter_notify: drained %d\n", i);
+}
+
+void
 set_win_state(struct ws_win *win, long state)
 {
 	long			data[] = {state, None};
@@ -1448,7 +1497,8 @@ config_win(struct ws_win *win, XConfigureRequestEvent  *ev)
 		return;
 
 	if (ev == NULL) {
-		DNPRINTF(SWM_D_MISC, "config_win: win %lu x %d y %d w %d h %d\n",
+		DNPRINTF(SWM_D_MISC,
+		    "config_win: win %lu x %d y %d w %d h %d\n",
 		    win->id, win->g.x, win->g.y, win->g.w, win->g.h);
 
 		ce.type = ConfigureNotify;
@@ -1463,7 +1513,8 @@ config_win(struct ws_win *win, XConfigureRequestEvent  *ev)
 		ce.above = None;
 		ce.override_redirect = False;
 	} else {
-		DNPRINTF(SWM_D_MISC, "config_win: ev win %lu x %d y %d w %d h %d\n",
+		DNPRINTF(SWM_D_MISC,
+		    "config_win: ev win %lu x %d y %d w %d h %d\n",
 		    ev->window, ev->x, ev->y, ev->width, ev->height);
 		ce.type = ConfigureNotify;
 		ce.display = ev->display;
@@ -1665,7 +1716,7 @@ find_window(Window id)
 }
 
 void
-spawn(struct swm_region *r, union arg *args, int close_fd)
+spawn(int ws_idx, union arg *args, int close_fd)
 {
 	int			fd;
 	char			*ret = NULL;
@@ -1677,7 +1728,7 @@ spawn(struct swm_region *r, union arg *args, int close_fd)
 
 	setenv("LD_PRELOAD", SWM_LIB, 1);
 
-	if (asprintf(&ret, "%d", r->ws->idx) == -1) {
+	if (asprintf(&ret, "%d", ws_idx) == -1) {
 		perror("_SWM_WS");
 		_exit(1);
 	}
@@ -1725,10 +1776,11 @@ spawnterm(struct swm_region *r, union arg *args)
 {
 	DNPRINTF(SWM_D_MISC, "spawnterm\n");
 
-	if (term_width)
-		setenv("_SWM_XTERM_FONTADJ", "", 1);
-	if (fork() == 0)
-		spawn(r, args, 1);
+	if (fork() == 0) {
+		if (term_width)
+			setenv("_SWM_XTERM_FONTADJ", "", 1);
+		spawn(r->ws->idx, args, 1);
+	}
 }
 
 void
@@ -1761,7 +1813,7 @@ validate_win(struct ws_win *testwin)
 	int			i, x, foundit = 0;
 
 	if (testwin == NULL)
-		return(0);
+		return (0);
 
 	for (i = 0, foundit = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
@@ -1889,6 +1941,13 @@ focus_win(struct ws_win *win)
 	XGetInputFocus(display, &cur_focus, &rr);
 	if ((cfw = find_window(cur_focus)) != NULL)
 		unfocus_win(cfw);
+	else {
+		/* use larger hammer since the window was killed somehow */
+		TAILQ_FOREACH(cfw, &win->ws->winlist, entry)
+			if (cfw->ws && cfw->ws->r && cfw->ws->r->s)
+				XSetWindowBorder(display, cfw->id,
+				    cfw->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+	}
 
 	win->ws->focus = win;
 
@@ -1956,15 +2015,22 @@ switchws(struct swm_region *r, union arg *args)
 	this_r->ws = new_ws;
 	new_ws->r = this_r;
 
+	/* this is needed so that we can click on a window after a restart */
+	unfocus_all();
+
 	stack();
 	a.id = SWM_ARG_ID_FOCUSCUR;
 	focus(new_ws->r, &a);
+
 	bar_update();
 
 	/* unmap old windows */
 	if (unmap_old)
 		TAILQ_FOREACH(win, &old_ws->winlist, entry)
 			unmap_window(win);
+
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
@@ -2141,7 +2207,7 @@ swapwin(struct swm_region *r, union arg *args)
 				source = source->ws->focus_prev;
 			else
 				return;
-                }
+		}
 		if (target == NULL || source == NULL)
 			return;
 		source->ws->focus_prev = target;
@@ -2200,7 +2266,8 @@ focus_prev(struct ws_win *win)
 	}
 
 	/* if in max_stack try harder */
-	if (ws->cur_layout->flags & SWM_L_FOCUSPREV) {
+	if ((win->quirks & SWM_Q_FOCUSPREV) ||
+	    (ws->cur_layout->flags & SWM_L_FOCUSPREV)) {
 		if (cur_focus != ws->focus_prev)
 			winfocus = ws->focus_prev;
 		else if (cur_focus != ws->focus)
@@ -2325,6 +2392,8 @@ cycle_layout(struct swm_region *r, union arg *args)
 		ws->cur_layout = &layouts[0];
 
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 	a.id = SWM_ARG_ID_FOCUSCUR;
 	focus(r, &a);
 	bar_update();
@@ -2341,7 +2410,7 @@ stack_config(struct swm_region *r, union arg *args)
 	if (ws->cur_layout->l_config != NULL)
 		ws->cur_layout->l_config(ws, args->id);
 
-	if (args->id != SWM_ARG_ID_STACKINIT);
+	if (args->id != SWM_ARG_ID_STACKINIT)
 		stack();
 }
 
@@ -2375,6 +2444,9 @@ stack(void) {
 	}
 	if (font_adjusted)
 		font_adjusted--;
+
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
@@ -2439,8 +2511,10 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 		 * floaters and transients are auto-centred unless moved
 		 * or resized
 		 */
-		win->g.x = r->g.x + (WIDTH(r) - win->g.w) / 2 - wc.border_width;
-		win->g.y = r->g.y + (HEIGHT(r) - win->g.h) / 2 - wc.border_width;
+		win->g.x = r->g.x + (WIDTH(r) - win->g.w) /
+		    2 - wc.border_width;
+		win->g.y = r->g.y + (HEIGHT(r) - win->g.h) /
+		    2 - wc.border_width;
 	}
 
 	/* win can be outside r if new r smaller than old r */
@@ -2530,7 +2604,8 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 		return;
 
 	TAILQ_FOREACH(win, &ws->winlist, entry)
-		if (win->transient == 0 && win->floating == 0 && win->iconic == 0)
+		if (win->transient == 0 && win->floating == 0
+		    && win->iconic == 0)
 			break;
 
 	if (win == NULL)
@@ -2579,7 +2654,8 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 	} else {
 		msize = -2;
 		colno = split = winno / stacks;
-		win_g.w = ((r_g.w - (stacks * 2 * border_width) + 2 * border_width) / stacks);
+		win_g.w = ((r_g.w - (stacks * 2 * border_width) +
+		    2 * border_width) / stacks);
 	}
 	hrh = r_g.h / colno;
 	extra = r_g.h - (colno * hrh);
@@ -2609,10 +2685,11 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 				win_g.x = r_g.x;
 			else
 				win_g.x += win_g.w + 2 * border_width;
-			win_g.w = (r_g.w - msize - (stacks * 2 * border_width)) / stacks;
+			win_g.w = (r_g.w - msize -
+			    (stacks * 2 * border_width)) / stacks;
 			if (s == 1)
-				win_g.w += (r_g.w - msize - (stacks * 2 * border_width)) %
-				    stacks;
+				win_g.w += (r_g.w - msize -
+				    (stacks * 2 * border_width)) % stacks;
 			s--;
 			j = 0;
 		}
@@ -2934,6 +3011,8 @@ iconify(struct swm_region *r, union arg *args)
 	unmap_window(r->ws->focus);
 	update_iconic(r->ws->focus, 1);
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 	r->ws->focus = NULL;
 	a.id = SWM_ARG_ID_FOCUSCUR;
 	focus(r, &a);
@@ -3137,6 +3216,8 @@ floating_toggle(struct swm_region *r, union arg *args)
 	    _NET_WM_STATE_TOGGLE);
 
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 
 	if (win == win->ws->focus) {
 		a.id = SWM_ARG_ID_FOCUSCUR;
@@ -3176,7 +3257,6 @@ resize(struct ws_win *win, union arg *args)
 	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 %lu\n",
@@ -3192,10 +3272,10 @@ resize(struct ws_win *win, union arg *args)
 	win->manual = 1;
 	ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom,
 	    _NET_WM_STATE_ADD);
-	/* raise the window = move to last in window list */
-	a.id = SWM_ARG_ID_MOVELAST;
-	swapwin(r, &a);
+
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 
 	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
 	    GrabModeAsync, None, None /* cursor */, CurrentTime) != GrabSuccess)
@@ -3216,7 +3296,7 @@ resize(struct ws_win *win, union arg *args)
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
-		switch(ev.type) {
+		switch (ev.type) {
 		case ConfigureRequest:
 		case Expose:
 		case MapRequest:
@@ -3257,7 +3337,7 @@ resize(struct ws_win *win, union arg *args)
 	XUngrabPointer(display, CurrentTime);
 
 	/* drain events */
-	while (XCheckMaskEvent(display, EnterWindowMask, &ev));
+	drain_enter_notify();
 }
 
 void
@@ -3286,7 +3366,6 @@ move(struct ws_win *win, union arg *args)
 	XEvent			ev;
 	Time			time = 0;
 	struct swm_region	*r = win->ws->r;
-	union arg		a;
 
 	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %lu\n",
 	    win->id, win->floating, win->transient);
@@ -3297,16 +3376,12 @@ move(struct ws_win *win, union arg *args)
 
 	win->manual = 1;
 	if (win->floating == 0 && !win->transient) {
-		win->floating = 1;
 		ewmh_update_win_state(win, ewmh[_NET_WM_STATE_ABOVE].atom,
 		    _NET_WM_STATE_ADD);
 	}
 	ewmh_update_win_state(win, ewmh[_SWM_WM_STATE_MANUAL].atom,
 	    _NET_WM_STATE_ADD);
 
-	/* 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,
@@ -3316,7 +3391,7 @@ move(struct ws_win *win, union arg *args)
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
-		switch(ev.type) {
+		switch (ev.type) {
 		case ConfigureRequest:
 		case Expose:
 		case MapRequest:
@@ -3351,7 +3426,7 @@ move(struct ws_win *win, union arg *args)
 	XUngrabPointer(display, CurrentTime);
 
 	/* drain events */
-	while (XCheckMaskEvent(display, EnterWindowMask, &ev));
+	drain_enter_notify();
 }
 
 /* user/key callable function IDs */
@@ -3633,7 +3708,7 @@ spawn_custom(struct swm_region *r, union arg *args, char *spawn_name)
 		return;
 	a.argv = real_args;
 	if (fork() == 0)
-		spawn(r, &a, 1);
+		spawn(r->ws->idx, &a, 1);
 
 	for (i = 0; i < spawn_argc; i++)
 		free(real_args[i]);
@@ -3669,7 +3744,7 @@ spawn_select(struct swm_region *r, union arg *args, char *spawn_name, int *pid)
 			errx(1, "dup2");
 		close(select_list_pipe[1]);
 		close(select_resp_pipe[0]);
-		spawn(r, &a, 0);
+		spawn(r->ws->idx, &a, 0);
 		break;
 	default: /* parent */
 		close(select_list_pipe[0]);
@@ -3790,8 +3865,9 @@ setconfspawn(char *selector, char *value, int flags)
 			cp += (long)strspn(cp, " \t");
 		if (strlen(word) > 0) {
 			prog->argc++;
-			prog->argv = realloc(prog->argv,
-			    prog->argc * sizeof(char *));
+			if ((prog->argv = realloc(prog->argv,
+			    prog->argc * sizeof(char *))) == NULL)
+				err(1, "setconfspawn: realloc");
 			if ((prog->argv[prog->argc - 1] = strdup(word)) == NULL)
 				err(1, "setconfspawn: strdup");
 		}
@@ -3890,7 +3966,8 @@ strdupsafe(char *str)
 }
 
 void
-setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name)
+setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid,
+    char *spawn_name)
 {
 	int			i, j;
 	DNPRINTF(SWM_D_KEY, "setkeybinding: enter %s [%s]\n",
@@ -3937,7 +4014,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 		keys_size = 4;
 		DNPRINTF(SWM_D_KEY, "setkeybinding: init list %d\n", keys_size);
 		keys = malloc((size_t)keys_size * sizeof(struct key));
-		if (!keys) {
+		if (keys == NULL) {
 			fprintf(stderr, "malloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -3946,7 +4023,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 		keys_size *= 2;
 		DNPRINTF(SWM_D_KEY, "setkeybinding: grow list %d\n", keys_size);
 		keys = realloc(keys, (size_t)keys_size * sizeof(struct key));
-		if (!keys) {
+		if (keys == NULL) {
 			fprintf(stderr, "realloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -3962,7 +4039,7 @@ setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid, char *spawn_name
 		keys[j].spawn_name = strdupsafe(spawn_name);
 	} else {
 		fprintf(stderr, "keys array problem?\n");
-		if (!keys) {
+		if (keys == NULL) {
 			fprintf(stderr, "keys array problem\n");
 			quit(NULL, NULL);
 		}
@@ -4093,7 +4170,7 @@ updatenumlockmask(void)
 	for (i = 0; i < 8; i++)
 		for (j = 0; j < modmap->max_keypermod; j++)
 			if (modmap->modifiermap[i * modmap->max_keypermod + j]
-			  == XKeysymToKeycode(display, XK_Num_Lock))
+			    == XKeysymToKeycode(display, XK_Num_Lock))
 				numlockmask = (1 << i);
 
 	XFreeModifiermap(modmap);
@@ -4155,6 +4232,7 @@ const char *quirkname[] = {
 	"ANYWHERE",
 	"XTERM_FONTADJ",
 	"FULLSCREEN",
+	"FOCUSPREV",
 };
 
 /* SWM_Q_WS: retain '|' for back compat for now (2009-08-11) */
@@ -4175,7 +4253,8 @@ parsequirks(char *qstr, unsigned long *quirk)
 			cp += (long)strspn(cp, SWM_Q_WS);
 		for (i = 0; i < LENGTH(quirkname); i++) {
 			if (!strncasecmp(name, quirkname[i], SWM_QUIRK_LEN)) {
-				DNPRINTF(SWM_D_QUIRK, "parsequirks: %s\n", name);
+				DNPRINTF(SWM_D_QUIRK,
+				    "parsequirks: %s\n", name);
 				if (i == 0) {
 					*quirk = 0;
 					return (0);
@@ -4238,7 +4317,7 @@ setquirk(const char *class, const char *name, const int quirk)
 		quirks_size = 4;
 		DNPRINTF(SWM_D_QUIRK, "setquirk: init list %d\n", quirks_size);
 		quirks = malloc((size_t)quirks_size * sizeof(struct quirk));
-		if (!quirks) {
+		if (quirks == NULL) {
 			fprintf(stderr, "setquirk: malloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -4246,8 +4325,9 @@ setquirk(const char *class, const char *name, const int quirk)
 	} else if (quirks_length == quirks_size) {
 		quirks_size *= 2;
 		DNPRINTF(SWM_D_QUIRK, "setquirk: grow list %d\n", quirks_size);
-		quirks = realloc(quirks, (size_t)quirks_size * sizeof(struct quirk));
-		if (!quirks) {
+		quirks = realloc(quirks,
+		    (size_t)quirks_size * sizeof(struct quirk));
+		if (quirks == NULL) {
 			fprintf(stderr, "setquirk: realloc failed\n");
 			perror(" failed");
 			quit(NULL, NULL);
@@ -4261,7 +4341,7 @@ setquirk(const char *class, const char *name, const int quirk)
 		quirks[j].quirk = quirk;
 	} else {
 		fprintf(stderr, "quirks array problem?\n");
-		if (!quirks) {
+		if (quirks == NULL) {
 			fprintf(stderr, "quirks array problem!\n");
 			quit(NULL, NULL);
 		}
@@ -4289,7 +4369,7 @@ setconfquirk(char *selector, char *value, int flags)
 void
 setup_quirks(void)
 {
-	setquirk("MPlayer",		"xv",		SWM_Q_FLOAT | SWM_Q_FULLSCREEN);
+	setquirk("MPlayer",		"xv",		SWM_Q_FLOAT | SWM_Q_FULLSCREEN | SWM_Q_FOCUSPREV);
 	setquirk("OpenOffice.org 3.2",	"VCLSalFrame",	SWM_Q_FLOAT);
 	setquirk("Firefox-bin",		"firefox-bin",	SWM_Q_TRANSSZ);
 	setquirk("Firefox",		"Dialog",	SWM_Q_FLOAT);
@@ -4301,18 +4381,20 @@ setup_quirks(void)
 	setquirk("Xitk",		"Xine Window",	SWM_Q_FLOAT | SWM_Q_ANYWHERE);
 	setquirk("xine",		"xine Video Fullscreen Window",	SWM_Q_FULLSCREEN | SWM_Q_FLOAT);
 	setquirk("pcb",			"pcb",		SWM_Q_FLOAT);
+	setquirk("SDL_App",		"SDL_App",	SWM_Q_FLOAT | SWM_Q_FULLSCREEN);
 }
 
 /* conf file stuff */
 #define SWM_CONF_FILE	"scrotwm.conf"
 
-enum	{ SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_BAR_BORDER_WIDTH, SWM_S_STACK_ENABLED,
-	  SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT, SWM_S_CYCLE_EMPTY,
-	  SWM_S_CYCLE_VISIBLE, SWM_S_SS_ENABLED, SWM_S_TERM_WIDTH,
-	  SWM_S_TITLE_CLASS_ENABLED, SWM_S_TITLE_NAME_ENABLED, SWM_S_WINDOW_NAME_ENABLED,
-	  SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BORDER_WIDTH, SWM_S_BAR_FONT,
-	  SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM, SWM_S_SS_APP, SWM_S_DIALOG_RATIO,
-	  SWM_S_BAR_AT_BOTTOM
+enum	{ SWM_S_BAR_DELAY, SWM_S_BAR_ENABLED, SWM_S_BAR_BORDER_WIDTH,
+	  SWM_S_STACK_ENABLED, SWM_S_CLOCK_ENABLED, SWM_S_CLOCK_FORMAT,
+	  SWM_S_CYCLE_EMPTY, SWM_S_CYCLE_VISIBLE, SWM_S_SS_ENABLED,
+	  SWM_S_TERM_WIDTH, SWM_S_TITLE_CLASS_ENABLED,
+	  SWM_S_TITLE_NAME_ENABLED, SWM_S_WINDOW_NAME_ENABLED,
+	  SWM_S_FOCUS_MODE, SWM_S_DISABLE_BORDER, SWM_S_BORDER_WIDTH,
+	  SWM_S_BAR_FONT, SWM_S_BAR_ACTION, SWM_S_SPAWN_TERM,
+	  SWM_S_SS_APP, SWM_S_DIALOG_RATIO, SWM_S_BAR_AT_BOTTOM
 	};
 
 int
@@ -4439,17 +4521,116 @@ setconfregion(char *selector, char *value, int flags)
 	return (0);
 }
 
+int
+setautorun(char *selector, char *value, int flags)
+{
+	int			ws_id;
+	char			s[1024];
+	char			*ap, *sp = s;
+	union arg		a;
+	int			argc = 0;
+	long			pid;
+	struct pid_e		*p;
+
+	if (getenv("SWM_STARTED"))
+		return (0);
+
+	bzero(s, sizeof s);
+	if (sscanf(value, "ws[%d]:%1023c", &ws_id, s) != 2)
+		errx(1, "invalid autorun entry, should be 'ws[<idx>]:command'\n");
+	ws_id--;
+	if (ws_id < 0 || ws_id >= SWM_WS_MAX)
+		errx(1, "autorun: invalid workspace %d\n", ws_id + 1);
+
+	/*
+	 * This is a little intricate
+	 *
+	 * If the pid already exists we simply reuse it because it means it was
+	 * used before AND not claimed by manage_window.  We get away with
+	 * altering it in the parent after INSERT because this can not be a race
+	 */
+	a.argv = NULL;
+	while ((ap = strsep(&sp, " \t")) != NULL) {
+		if (*ap == '\0')
+			continue;
+		DNPRINTF(SWM_D_SPAWN, "setautorun: arg [%s]\n", ap);
+		argc++;
+		if ((a.argv = realloc(a.argv, argc * sizeof(char *))) == NULL)
+			err(1, "setautorun: realloc");
+		a.argv[argc - 1] = ap;
+	}
+
+	if ((a.argv = realloc(a.argv, (argc + 1) * sizeof(char *))) == NULL)
+		err(1, "setautorun: realloc");
+	a.argv[argc] = NULL;
+
+	if ((pid = fork()) == 0) {
+		spawn(ws_id, &a, 1);
+		/* NOTREACHED */
+		_exit(1);
+	}
+	free(a.argv);
+
+	/* parent */
+	p = find_pid(pid);
+	if (p == NULL) {
+		p = calloc(1, sizeof *p);
+		if (p == NULL)
+			return (1);
+		TAILQ_INSERT_TAIL(&pidlist, p, entry);
+	}
+
+	p->pid = pid;
+	p->ws = ws_id;
+
+	return (0);
+}
+
+int
+setlayout(char *selector, char *value, int flags)
+{
+	int			ws_id, st, i;
+	char			s[1024];
+	struct workspace	*ws;
+
+	if (getenv("SWM_STARTED"))
+		return (0);
+
+	bzero(s, sizeof s);
+	if (sscanf(value, "ws[%d]:%1023c", &ws_id, s) != 2)
+		errx(1, "invalid layout entry, should be 'ws[<idx>]:<type>'\n");
+	ws_id--;
+	if (ws_id < 0 || ws_id >= SWM_WS_MAX)
+		errx(1, "layout: invalid workspace %d\n", ws_id + 1);
+
+	if (!strcasecmp(s, "vertical"))
+		st = SWM_V_STACK;
+	else if (!strcasecmp(s, "horizontal"))
+		st = SWM_H_STACK;
+	else if (!strcasecmp(s, "fullscreen"))
+		st = SWM_MAX_STACK;
+	else
+		errx(1, "invalid layout entry, should be 'ws[<idx>]:<type>'\n");
+
+	for (i = 0; i < ScreenCount(display); i++) {
+		ws = (struct workspace *)&screens[i].ws;
+		ws[ws_id].cur_layout = &layouts[st];
+	}
+
+	return (0);
+}
+
 /* config options */
 struct config_option {
 	char			*optname;
-	int (*func)(char*, char*, int);
-	int funcflags;
+	int			(*func)(char*, char*, int);
+	int			funcflags;
 };
 struct config_option configopt[] = {
 	{ "bar_enabled",		setconfvalue,	SWM_S_BAR_ENABLED },
 	{ "bar_at_bottom",		setconfvalue,	SWM_S_BAR_AT_BOTTOM },
 	{ "bar_border",			setconfcolor,	SWM_S_COLOR_BAR_BORDER },
-	{ "bar_border_width",			setconfvalue,	SWM_S_BAR_BORDER_WIDTH },
+	{ "bar_border_width",		setconfvalue,	SWM_S_BAR_BORDER_WIDTH },
 	{ "bar_color",			setconfcolor,	SWM_S_COLOR_BAR },
 	{ "bar_font_color",		setconfcolor,	SWM_S_COLOR_BAR_FONT },
 	{ "bar_font",			setconfvalue,	SWM_S_BAR_FONT },
@@ -4475,9 +4656,11 @@ struct config_option configopt[] = {
 	{ "term_width",			setconfvalue,	SWM_S_TERM_WIDTH },
 	{ "title_class_enabled",	setconfvalue,	SWM_S_TITLE_CLASS_ENABLED },
 	{ "title_name_enabled",		setconfvalue,	SWM_S_TITLE_NAME_ENABLED },
-	{ "focus_mode",			setconfvalue,   SWM_S_FOCUS_MODE },
-	{ "disable_border",		setconfvalue,   SWM_S_DISABLE_BORDER },
-	{ "border_width",		setconfvalue,   SWM_S_BORDER_WIDTH },
+	{ "focus_mode",			setconfvalue,	SWM_S_FOCUS_MODE },
+	{ "disable_border",		setconfvalue,	SWM_S_DISABLE_BORDER },
+	{ "border_width",		setconfvalue,	SWM_S_BORDER_WIDTH },
+	{ "autorun",			setautorun,	0 },
+	{ "layout",			setlayout,	0 },
 };
 
 
@@ -4578,13 +4761,98 @@ conf_load(char *filename)
 }
 
 void
-set_child_transient(struct ws_win *win)
+set_child_transient(struct ws_win *win, Window *trans)
 {
-	struct ws_win		*parent;
+	struct ws_win		*parent, *w;
+	XWMHints		*wmh = NULL;
+	struct swm_region	*r;
+	struct workspace	*ws;
 
 	parent = find_window(win->transient);
 	if (parent)
 		parent->child_trans = win;
+	else {
+		DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist"
+		    " for %lu trans %lu\n", win->id, win->transient);
+
+		if (win->hints == NULL) {
+			fprintf(stderr, "no hints for %lu\n", win->id);
+			return;
+		}
+
+		r = root_to_region(win->wa.root);
+		ws = r->ws;
+		/* parent doen't exist in our window list */
+		TAILQ_FOREACH(w, &ws->winlist, entry) {
+			if (wmh)
+				XFree(wmh);
+
+			if ((wmh = XGetWMHints(display, w->id)) == NULL) {
+				fprintf(stderr, "can't get hints for %lu\n",
+				    w->id);
+				continue;
+			}
+
+			if (win->hints->window_group != wmh->window_group)
+				continue;
+
+			w->child_trans = win;
+			win->transient = w->id;
+			*trans = w->id;
+			DNPRINTF(SWM_D_MISC, "set_child_transient: asjusting "
+			    "transient to %lu\n", win->transient);
+			break;
+		}
+	}
+
+	if (wmh)
+		XFree(wmh);
+}
+
+long
+window_get_pid(Window win)
+{
+	Atom			actual_type_return;
+	int			actual_format_return = 0;
+	unsigned long		nitems_return = 0;
+	unsigned long		bytes_after_return = 0;
+	long			*pid = NULL;
+	long			ret = 0;
+	const char		*errstr;
+	unsigned char		*prop = NULL;
+
+	if (XGetWindowProperty(display, win,
+	    XInternAtom(display, "_NET_WM_PID", False), 0, 1, False,
+	    XA_CARDINAL, &actual_type_return, &actual_format_return,
+	    &nitems_return, &bytes_after_return,
+	    (unsigned char**)(void*)&pid) != Success)
+		goto tryharder;
+	if (actual_type_return != XA_CARDINAL)
+		goto tryharder;
+	if (pid == NULL)
+		goto tryharder;
+
+	ret = *pid;
+	XFree(pid);
+
+	return (ret);
+
+tryharder:
+	if (XGetWindowProperty(display, win,
+	    XInternAtom(display, "_SWM_PID", False), 0, SWM_PROPLEN, False,
+	    XA_STRING, &actual_type_return, &actual_format_return,
+	    &nitems_return, &bytes_after_return, &prop) != Success)
+		return (0);
+	if (actual_type_return != XA_STRING)
+		return (0);
+	if (prop == NULL)
+		return (0);
+
+	ret = strtonum(prop, 0, UINT_MAX, &errstr);
+	/* ignore error because strtonum returns 0 anyway */
+	XFree(prop);
+
+	return (ret);
 }
 
 struct ws_win *
@@ -4602,6 +4870,7 @@ manage_window(Window id)
 	long			mask;
 	const char		*errstr;
 	XWindowChanges		wc;
+	struct pid_e		*p;
 
 	if ((win = find_window(id)) != NULL)
 		return (win);	/* already being managed */
@@ -4611,9 +4880,9 @@ manage_window(Window id)
 		DNPRINTF(SWM_D_MISC, "manage previously unmanaged window "
 		    "%lu\n", win->id);
 		TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
-		if (win->transient)
-			set_child_transient(win);
-		if (trans && (ww = find_window(trans)))
+		if (win->transient) {
+			set_child_transient(win, &trans);
+		} if (trans && (ww = find_window(trans)))
 			TAILQ_INSERT_AFTER(&win->ws->winlist, ww, win, entry);
 		else
 			TAILQ_INSERT_TAIL(&win->ws->winlist, win, entry);
@@ -4626,17 +4895,22 @@ manage_window(Window id)
 
 	win->id = id;
 
+	/* see if we need to override the workspace */
+	p = find_pid(window_get_pid(id));
+
 	/* Get all the window data in one shot */
 	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
-	if (ws_idx_atom)
+	if (ws_idx_atom) {
 		XGetWindowProperty(display, id, ws_idx_atom, 0, SWM_PROPLEN,
 		    False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
+	}
 	XGetWindowAttributes(display, id, &win->wa);
 	XGetWMNormalHints(display, id, &win->sh, &mask);
+	win->hints = XGetWMHints(display, id);
 	XGetTransientForHint(display, id, &trans);
 	if (trans) {
 		win->transient = trans;
-		set_child_transient(win);
+		set_child_transient(win, &trans);
 		DNPRINTF(SWM_D_MISC, "manage_window: win %lu transient %lu\n",
 		    win->id, win->transient);
 	}
@@ -4661,7 +4935,12 @@ manage_window(Window id)
 	 * transient, * put it in the same workspace
 	 */
 	r = root_to_region(win->wa.root);
-	if (prop && win->transient == 0) {
+	if (p) {
+		ws = &r->s->ws[p->ws];
+		TAILQ_REMOVE(&pidlist, p, entry);
+		free(p);
+		p = NULL;
+	} else if (prop && win->transient == 0) {
 		DNPRINTF(SWM_D_PROP, "got property _SWM_WS=%s\n", prop);
 		ws_idx = strtonum(prop, 0, 9, &errstr);
 		if (errstr) {
@@ -4891,8 +5170,8 @@ keypress(XEvent *e)
 	keysym = XKeycodeToKeysym(display, (KeyCode)ev->keycode, 0);
 	for (i = 0; i < keys_length; i++)
 		if (keysym == keys[i].keysym
-		   && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
-		   && keyfuncs[keys[i].funcid].func) {
+		    && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
+		    && keyfuncs[keys[i].funcid].func) {
 			if (keys[i].funcid == kf_spawn_custom)
 				spawn_custom(
 				    root_to_region(ev->root),
@@ -4976,6 +5255,8 @@ configurenotify(XEvent *e)
 		adjust_font(win);
 		if (font_adjusted)
 			stack();
+		if (focus_mode == SWM_FOCUS_DEFAULT)
+			drain_enter_notify();
 	}
 }
 
@@ -4999,6 +5280,8 @@ destroynotify(XEvent *e)
 
 	unmanage_window(win);
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 	free_window(win);
 }
 
@@ -5020,11 +5303,6 @@ enternotify(XEvent *e)
 
 	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;
@@ -5290,6 +5568,9 @@ unmapnotify(XEvent *e)
 		/* resend unmap because we ated it */
 		XUnmapWindow(display, e->xunmap.window);
 	}
+
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
@@ -5334,7 +5615,8 @@ clientmessage(XEvent *e)
 			XKillClient(display, win->id);
 	}
 	if (ev->message_type == ewmh[_NET_MOVERESIZE_WINDOW].atom) {
-		DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_MOVERESIZE_WINDOW \n");
+		DNPRINTF(SWM_D_EVENT,
+		    "clientmessage: _NET_MOVERESIZE_WINDOW \n");
 		if (win->floating) {
 			if (ev->data.l[0] & (1<<8)) /* x */
 				win->g.x = ev->data.l[1];
@@ -5354,7 +5636,8 @@ clientmessage(XEvent *e)
 		DNPRINTF(SWM_D_EVENT, "clientmessage: _NET_WM_STATE \n");
 		ewmh_update_win_state(win, ev->data.l[1], ev->data.l[0]);
 		if (ev->data.l[2])
-			ewmh_update_win_state(win, ev->data.l[2], ev->data.l[0]);
+			ewmh_update_win_state(win, ev->data.l[2],
+			    ev->data.l[0]);
 
 		stack();
 	}
@@ -5551,6 +5834,8 @@ screenchange(XEvent *e) {
 		TAILQ_FOREACH(r, &screens[i].rl, entry)
 			bar_setup(r);
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 }
 
 void
@@ -5604,14 +5889,11 @@ setup_screens(void)
 	int			i, j, k;
 	int			errorbase, major, minor;
 	struct workspace	*ws;
-	int			ws_idx_atom;
 
 	if ((screens = calloc(ScreenCount(display),
 	     sizeof(struct swm_screen))) == NULL)
 		errx(1, "calloc: screens");
 
-	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
-
 	/* initial Xrandr setup */
 	xrandr_support = XRRQueryExtension(display,
 	    &xrandr_eventbase, &errorbase);
@@ -5791,6 +6073,9 @@ main(int argc, char *argv[])
 	/* grab existing windows (before we build the bars) */
 	grab_windows();
 
+	if (getenv("SWM_STARTED") == NULL)
+		setenv("SWM_STARTED", "YES", 1);
+
 	/* setup all bars */
 	for (i = 0; i < ScreenCount(display); i++)
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {
@@ -5803,6 +6088,8 @@ main(int argc, char *argv[])
 
 	grabkeys();
 	stack();
+	if (focus_mode == SWM_FOCUS_DEFAULT)
+		drain_enter_notify();
 
 	xfd = ConnectionNumber(display);
 	while (running) {