X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=scrotwm.c;h=70aee79463e69f5fa3e9ce508b4c40f896ade0dd;hb=6392bc78077595ba35d63693a54ab66bb00e9077;hp=d7fa44ea6f60db5cfe96f35bae64929e5e66c1fa;hpb=0337f0c525ce35622fc7d03ef4942cdb9240aed1;p=spectrwm.git

diff --git a/scrotwm.c b/scrotwm.c
index d7fa44e..70aee79 100644
--- a/scrotwm.c
+++ b/scrotwm.c
@@ -2,6 +2,8 @@
 /*
  * Copyright (c) 2009 Marco Peereboom <marco@peereboom.us>
  * Copyright (c) 2009 Ryan McBride <mcbride@countersiege.com>
+ * Copyright (c) 2009 Darrin Chandler <dwchandler@stilyagin.com>
+ * Copyright (c) 2009 Pierre-Yves Ritschard <pyr@spootnik.org>
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -50,7 +52,7 @@
 
 static const char	*cvstag = "$scrotwm$";
 
-#define	SWM_VERSION	"0.7"
+#define	SWM_VERSION	"0.9.5"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -105,6 +107,8 @@ static const char	*cvstag = "$scrotwm$";
 #define	SWM_D_MOUSE		0x0040
 #define	SWM_D_PROP		0x0080
 #define	SWM_D_CLASS		0x0100
+#define SWM_D_KEY		0x0200
+#define SWM_D_QUIRK		0x0400
 
 u_int32_t		swm_debug = 0
 			    | SWM_D_MISC
@@ -116,6 +120,8 @@ u_int32_t		swm_debug = 0
 			    | SWM_D_MOUSE
 			    | SWM_D_PROP
 			    | SWM_D_CLASS
+			    | SWM_D_KEY
+			    | SWM_D_QUIRK
 			    ;
 #else
 #define DPRINTF(x...)
@@ -128,10 +134,14 @@ u_int32_t		swm_debug = 0
 #define BUTTONMASK		(ButtonPressMask|ButtonReleaseMask)
 #define MOUSEMASK		(BUTTONMASK|PointerMotionMask)
 #define SWM_PROPLEN		(16)
-#define X(r)			(r)->g.x	
+#define SWM_FUNCNAME_LEN	(32)
+#define SWM_KEYS_LEN		(255)
+#define SWM_QUIRK_LEN		(64)
+#define X(r)			(r)->g.x
 #define Y(r)			(r)->g.y
-#define WIDTH(r)		(r)->g.w	
+#define WIDTH(r)		(r)->g.w
 #define HEIGHT(r)		(r)->g.h
+#define SWM_MAX_FONT_STEPS	(3)
 
 #ifndef SWM_LIB
 #define SWM_LIB			"/usr/X11R6/lib/swmhack.so"
@@ -139,10 +149,13 @@ u_int32_t		swm_debug = 0
 
 char			**start_argv;
 Atom			astate;
+Atom			aprot;
+Atom			adelete;
 int			(*xerrorxlib)(Display *, XErrorEvent *);
 int			other_wm;
 int			running = 1;
 int			ss_enabled = 0;
+int			xrandr_support;
 int			xrandr_eventbase;
 int			ignore_enter = 0;
 unsigned int		numlockmask = 0;
@@ -150,11 +163,13 @@ Display			*display;
 
 int			cycle_empty = 0;
 int			cycle_visible = 0;
+int			term_width = 0;
+int			font_adjusted = 0;
 
 /* dialog windows */
 double			dialog_ratio = .6;
 /* status bar */
-#define SWM_BAR_MAX	(128)
+#define SWM_BAR_MAX	(256)
 char			*bar_argv[] = { NULL, NULL };
 int			bar_pipe[2];
 char			bar_ext[SWM_BAR_MAX];
@@ -167,13 +182,16 @@ int			bar_extra = 1;
 int			bar_extra_running = 0;
 int			bar_verbose = 1;
 int			bar_height = 0;
+int			clock_enabled = 1;
+int			title_name_enabled = 0;
+int			title_class_enabled = 0;
 pid_t			bar_pid;
 GC			bar_gc;
 XGCValues		bar_gcv;
 int			bar_fidx = 0;
 XFontStruct		*bar_fs;
 char			*bar_fonts[] = {
-			    "-*-terminus-*-*-*-*-*-*-*-*-*-*-*-*",
+			    "-*-terminus-medium-*-*-*-*-*-*-*-*-*-*-*",
 			    "-*-times-medium-r-*-*-*-*-*-*-*-*-*-*",
 			    NULL
 };
@@ -182,6 +200,7 @@ char			*bar_fonts[] = {
 char			*spawn_term[] = { "xterm", NULL };
 char			*spawn_screenshot[] = { "screenshot.sh", NULL, NULL };
 char			*spawn_lock[] = { "xlock", NULL };
+char			*spawn_initscr[] = { "initscreen.sh", NULL };
 char			*spawn_menu[] = { "dmenu_run", "-fn", NULL, "-nb", NULL,
 			    "-nf", NULL, "-sb", NULL, "-sf", NULL, NULL };
 
@@ -206,9 +225,9 @@ struct workspace;
 struct swm_region {
 	TAILQ_ENTRY(swm_region)	entry;
 	struct swm_geometry	g;
-	Window			bar_window;
 	struct workspace 	*ws;	/* current workspace on this region */
 	struct swm_screen	*s;	/* screen idx */
+	Window			bar_window;
 }; 
 TAILQ_HEAD(swm_region_list, swm_region);
 
@@ -220,6 +239,11 @@ struct ws_win {
 	int			floating;
 	int			transient;
 	int			manual;
+	int			font_size_boundary[SWM_MAX_FONT_STEPS];
+	int			font_steps;
+	int			last_inc;
+	int			can_delete;
+	unsigned long		quirks;
 	struct workspace	*ws;	/* always valid */
 	struct swm_screen	*s;	/* always valid, never changes */
 	XWindowAttributes	wa;
@@ -228,6 +252,62 @@ 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_invalid
+};
+
 /* layout handlers */
 void	stack(void);
 void	vertical_config(struct workspace *, int);
@@ -237,6 +317,16 @@ void	horizontal_stack(struct workspace *, struct swm_geometry *);
 void	max_stack(struct workspace *, struct swm_geometry *);
 
 void	grabbuttons(struct ws_win *, int);
+void	new_region(struct swm_screen *, int, int, int, int);
+void	update_modkey(unsigned int);
+/* user functions / key binding */
+int	bindmatch(const char *var, const char *name, unsigned int currmod, char *keystr,
+    enum keyfuncid *kfid, unsigned int *mod, KeySym *ks);
+void	setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid);
+/* quirks */
+int	quirkmatch(const char *var, const char *name, char *qstr,
+    char *qclass, char *qname, unsigned long *qquirk);
+void	setquirk(const char *class, const char *name, const int quirk);
 
 struct layout {
 	void		(*l_stack)(struct workspace *, struct swm_geometry *);
@@ -258,6 +348,7 @@ struct workspace {
 	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 ws_win_list	winlist;	/* list of windows in ws */
 
@@ -265,8 +356,10 @@ struct workspace {
 	struct {
 				int horizontal_msize;
 				int horizontal_mwin;
+				int horizontal_stacks;
 				int vertical_msize;
 				int vertical_mwin;
+				int vertical_stacks;
 	} l_state;
 };
 
@@ -278,8 +371,8 @@ enum	{ SWM_S_COLOR_BAR, SWM_S_COLOR_BAR_BORDER, SWM_S_COLOR_BAR_FONT,
 struct swm_screen {
 	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;
-	int			xrandr_support;
 	struct workspace	ws[SWM_WS_MAX];
 
 	/* colors */
@@ -312,24 +405,30 @@ union arg {
 #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)
 	char			**argv;
 };
 
 /* quirks */
 struct quirk {
-	char			*class;
-	char			*name;
+	char			class[SWM_QUIRK_LEN];
+	char			name[SWM_QUIRK_LEN];
 	unsigned long		quirk;
-#define SWM_Q_FLOAT		(1<<0)
-} quirks[] = {
-	{ "MPlayer",		"xv",		SWM_Q_FLOAT },
-	{ "OpenOffice.org 2.4",	"VCLSalFrame",	SWM_Q_FLOAT },
-	{ NULL,		NULL,		0},
+#define SWM_Q_FLOAT		(1<<0)	/* float this window */
+#define SWM_Q_TRANSSZ		(1<<1)	/* transiend window size too small */
+#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 */
 };
+int				quirks_size = 0, quirks_length = 0;
+struct quirk			*quirks = NULL;
 
 /* events */
 void			expose(XEvent *);
@@ -340,6 +439,7 @@ void			configurenotify(XEvent *);
 void			destroynotify(XEvent *);
 void			enternotify(XEvent *);
 void			focusin(XEvent *);
+void			focusout(XEvent *);
 void			mappingnotify(XEvent *);
 void			maprequest(XEvent *);
 void			propertynotify(XEvent *);
@@ -355,6 +455,7 @@ void			(*handler[LASTEvent])(XEvent *) = {
 				[DestroyNotify] = destroynotify,
 				[EnterNotify] = enternotify,
 				[FocusIn] = focusin,
+				[FocusOut] = focusout,
 				[MappingNotify] = mappingnotify,
 				[MapRequest] = maprequest,
 				[PropertyNotify] = propertynotify,
@@ -404,6 +505,33 @@ setscreencolor(char *val, int i, int c)
 		    i, ScreenCount(display));
 }
 
+void
+custom_region(char *val)
+{
+	unsigned int			sidx, x, y, w, h;
+
+	if (sscanf(val, "screen[%u]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5)
+		errx(1, "invalid custom region, "
+		    "should be 'screen[<n>]:<n>x<n>+<n>+<n>\n");
+	if (sidx < 1 || sidx > ScreenCount(display))
+		errx(1, "invalid screen index: %d out of bounds (maximum %d)\n",
+		    sidx, ScreenCount(display));
+	sidx--;
+
+	if (w < 1 || h < 1)
+		errx(1, "region %ux%u+%u+%u too small\n", w, h, x, y);
+
+	if (x  < 0 || x > DisplayWidth(display, sidx) ||
+	    y < 0 || y > DisplayHeight(display, sidx) ||
+	    w + x > DisplayWidth(display, sidx) ||
+	    h + y > DisplayHeight(display, sidx))
+		errx(1, "region %ux%u+%u+%u not within screen boundaries "
+		    "(%ux%u)\n", w, h, x, y,
+		    DisplayWidth(display, sidx), DisplayHeight(display, sidx));
+	    
+	new_region(&screens[sidx], x, y, w, h);
+}
+
 int
 varmatch(char *var, char *name, int *index)
 {
@@ -440,6 +568,12 @@ conf_load(char *filename)
 	char			*line, *cp, *var, *val;
 	size_t			len, lineno = 0;
 	int			i, sc;
+	unsigned int 		modkey = MODKEY, modmask;
+	KeySym			ks;
+	enum keyfuncid		kfid;
+	char			class[SWM_QUIRK_LEN];
+	char			name[SWM_QUIRK_LEN];
+	unsigned long		quirk;
 
 	DNPRINTF(SWM_D_MISC, "conf_load: filename %s\n", filename);
 
@@ -483,12 +617,17 @@ conf_load(char *filename)
 				asprintf(&bar_argv[0], "%s", val);
 			else if (!strncmp(var, "bar_delay", strlen("bar_delay")))
 				bar_delay = atoi(val);
+			else if (!bindmatch(var, "bind", modkey, val,
+			    &kfid, &modmask, &ks))
+				setkeybinding(modmask, ks, kfid);
 			else
 				goto bad;
 			break;
 
 		case 'c':
-			if (!varmatch(var, "color_focus", &i))
+			if (!strncmp(var, "clock_enabled", strlen("clock_enabled")))
+				clock_enabled = atoi(val);
+			else if (!varmatch(var, "color_focus", &i))
 				setscreencolor(val, i, SWM_S_COLOR_FOCUS);
 			else if (!varmatch(var, "color_unfocus", &i))
 				setscreencolor(val, i, SWM_S_COLOR_UNFOCUS);
@@ -510,16 +649,62 @@ conf_load(char *filename)
 				goto bad;
 			break;
 
+		case 'm':
+			if (!strncmp(var, "modkey", strlen("modkey"))) {
+				modkey = MODKEY;
+				if (!strncmp(val, "Mod2", strlen("Mod2")))
+					modkey = Mod2Mask;
+				else if (!strncmp(val, "Mod3", strlen("Mod3")))
+					modkey = Mod3Mask;
+				else if (!strncmp(val, "Mod4", strlen("Mod4")))
+					modkey = Mod4Mask;
+				else
+					modkey = Mod1Mask;
+				update_modkey(modkey);
+			} else
+				goto bad;
+			break;
+
+		case 'q':
+			if (!quirkmatch(var, "quirk", val, class, name, &quirk))
+				setquirk(class, name, quirk);
+			else
+				goto bad;
+			break;
+
+		case 'r':
+			if (!strncmp(var, "region", strlen("region")))
+				custom_region(val);
+			else
+				goto bad;
+			break;
+
 		case 's':
 			if (!strncmp(var, "spawn_term", strlen("spawn_term")))
 				asprintf(&spawn_term[0], "%s", val);
-			if (!strncmp(var, "screenshot_enabled",
+			else if (!strncmp(var, "screenshot_enabled",
 			    strlen("screenshot_enabled")))
 				ss_enabled = atoi(val);
-			if (!strncmp(var, "screenshot_app",
+			else if (!strncmp(var, "screenshot_app",
 			    strlen("screenshot_app")))
 				asprintf(&spawn_screenshot[0], "%s", val);
+			else
+				goto bad;
 			break;
+
+		case 't':
+			if (!strncmp(var, "term_width", strlen("term_width")))
+				term_width = atoi(val);
+			else if (!strncmp(var, "title_class_enabled",
+			    strlen("title_class_enabled")))
+				title_class_enabled = atoi(val);
+			else if (!strncmp(var, "title_name_enabled",
+			    strlen("title_name_enabled")))
+				title_name_enabled = atoi(val);
+			else
+				goto bad;
+			break;
+
 		default:
 			goto bad;
 		}
@@ -580,10 +765,11 @@ bar_update(void)
 	char			s[SWM_BAR_MAX];
 	char			loc[SWM_BAR_MAX];
 	char			*b;
+	XClassHint		*xch;
+	Status			 status;
 
 	if (bar_enabled == 0)
 		return;
-
 	if (bar_extra && bar_extra_running) {
 		/* ignore short reads; it'll correct itself */
 		while ((b = fgetln(stdin, &len)) != NULL)
@@ -599,14 +785,36 @@ bar_update(void)
 	} else
 		strlcpy(bar_ext, "", sizeof bar_ext);
 
-	time(&tmt);
-	localtime_r(&tmt, &tm);
-	strftime(s, sizeof s, "%a %b %d %R %Z %Y", &tm);
+	if (clock_enabled == 0)
+		strlcpy(s, "", sizeof s);
+	else {
+		time(&tmt);
+		localtime_r(&tmt, &tm);
+		strftime(s, sizeof s, "%a %b %d %R %Z %Y    ", &tm);
+	}
+	xch = NULL;
+	if ((title_name_enabled == 1 || title_class_enabled == 1) &&
+	    cur_focus != NULL) {
+		if ((xch = XAllocClassHint()) == NULL)
+			goto out;
+		status = XGetClassHint(display, cur_focus->id, xch);
+		if (status == BadWindow || status == BadAlloc)
+			goto out;
+		if (title_class_enabled)
+			strlcat(s, xch->res_class, sizeof s);
+		if (title_name_enabled && title_class_enabled)
+			strlcat(s, ":", sizeof s);
+		if (title_name_enabled)
+			strlcat(s, xch->res_name, sizeof s);
+	}
+out:
+	if (xch)
+		XFree(xch);
 	for (i = 0; i < ScreenCount(display); i++) {
 		x = 1;
 		TAILQ_FOREACH(r, &screens[i].rl, entry) {
-			snprintf(loc, sizeof loc, "%s     %d:%d    %s    %s",
-			    s, x++, r->ws->idx + 1, bar_ext, bar_vertext);
+			snprintf(loc, sizeof loc, "%d:%d    %s %s    %s",
+			    x++, r->ws->idx + 1, s, bar_ext, bar_vertext);
 			bar_print(r, loc);
 		}
 	}
@@ -628,26 +836,23 @@ bar_toggle(struct swm_region *r, union arg *args)
 
 	DNPRINTF(SWM_D_MISC, "bar_toggle\n");
 
-	if (bar_enabled) {
+	if (bar_enabled)
 		for (i = 0; i < sc; i++)
 			TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
 				XUnmapWindow(display, tmpr->bar_window);
-	} else {
+	else
 		for (i = 0; i < sc; i++)
 			TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
 				XMapRaised(display, tmpr->bar_window);
-	}
+
 	bar_enabled = !bar_enabled;
-	XSync(display, False);
 	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 */
-	for (i = 0; i < sc; i++)
-		TAILQ_FOREACH(tmpr, &screens[i].rl, entry)
-			bar_update();
+	bar_update();
 }
 
 void
@@ -736,13 +941,29 @@ version(struct swm_region *r, union arg *args)
 {
 	bar_version = !bar_version;
 	if (bar_version)
-		strlcpy(bar_vertext, cvstag, sizeof bar_vertext);
+		snprintf(bar_vertext, sizeof bar_vertext, "Version: %s CVS: %s",
+		    SWM_VERSION, cvstag);
 	else
 		strlcpy(bar_vertext, "", sizeof bar_vertext);
 	bar_update();
 }
 
 void
+client_msg(struct ws_win *win, Atom a)
+{
+	XClientMessageEvent	cm;
+
+	bzero(&cm, sizeof cm);
+	cm.type = ClientMessage;
+	cm.window = win->id;
+	cm.message_type = aprot;
+	cm.format = 32;
+	cm.data.l[0] = a;
+	cm.data.l[1] = CurrentTime;
+	XSendEvent(display, win->id, False, 0L, (XEvent *)&cm);
+}
+
+void
 config_win(struct ws_win *win)
 {
 	XConfigureEvent		ce;
@@ -801,6 +1022,34 @@ unmap_all(void)
 }
 
 void
+fake_keypress(struct ws_win *win, int keysym, int modifiers)
+{
+	XKeyEvent event;
+
+	event.display = display;	/* Ignored, but what the hell */
+	event.window = win->id;
+	event.root = win->s->root;
+	event.subwindow = None;
+	event.time = CurrentTime;
+	event.x = win->g.x;
+	event.y = win->g.y;
+	event.x_root = 1;
+	event.y_root = 1;
+	event.same_screen = True;
+	event.keycode = XKeysymToKeycode(display, keysym);
+	event.state = modifiers;
+
+	event.type = KeyPress;
+	XSendEvent(event.display, event.window, True,
+	    KeyPressMask, (XEvent *)&event);
+
+	event.type = KeyRelease;
+	XSendEvent(event.display, event.window, True,
+	    KeyPressMask, (XEvent *)&event);
+
+}
+
+void
 restart(struct swm_region *r, union arg *args)
 {
 	DNPRINTF(SWM_D_MISC, "restart: %s\n", start_argv[0]);
@@ -823,7 +1072,7 @@ restart(struct swm_region *r, union arg *args)
 struct swm_region *
 root_to_region(Window root)
 {
-	struct swm_region	*r;
+	struct swm_region	*r = NULL;
 	Window			rr, cr;
 	int			i, x, y, wx, wy;
 	unsigned int		mask;
@@ -833,20 +1082,17 @@ root_to_region(Window root)
 			break;
 
 	if (XQueryPointer(display, screens[i].root, 
-	    &rr, &cr, &x, &y, &wx, &wy, &mask) == False) {
-		/* if we can't query the pointer, grab the first region */
-		r = TAILQ_FIRST(&screens[i].rl);
-	} else {
-		/* otherwise, choose a region based on pointer location */
-		TAILQ_FOREACH(r, &screens[i].rl, entry) {
+	    &rr, &cr, &x, &y, &wx, &wy, &mask) != False) {
+		/* choose a region based on pointer location */
+		TAILQ_FOREACH(r, &screens[i].rl, entry)
 			if (x >= X(r) && x <= X(r) + WIDTH(r) &&
 			    y >= Y(r) && y <= Y(r) + HEIGHT(r))
 				break;
-		}
-
-		if (r == NULL)
-			r = TAILQ_FIRST(&screens[i].rl);
 	}
+
+	if (r == NULL)
+		r = TAILQ_FIRST(&screens[i].rl);
+
 	return (r);
 }
 
@@ -905,6 +1151,16 @@ spawn(struct swm_region *r, union arg *args)
 }
 
 void
+spawnterm(struct swm_region *r, union arg *args)
+{
+	DNPRINTF(SWM_D_MISC, "spawnterm\n");
+
+	if (term_width)
+		setenv("_SWM_XTERM_FONTADJ", "", 1);
+	spawn(r, args);
+}
+
+void
 spawnmenu(struct swm_region *r, union arg *args)
 {
 	DNPRINTF(SWM_D_MISC, "spawnmenu\n");
@@ -919,6 +1175,28 @@ spawnmenu(struct swm_region *r, union arg *args)
 }
 
 void
+unfocus_win(struct ws_win *win)
+{
+	if (win == NULL)
+		return;
+
+	if (win->ws->focus != win && win->ws->focus != NULL)
+		win->ws->focus_prev = win->ws->focus;
+
+	if (win->ws->r == NULL)
+		return;
+
+	grabbuttons(win, 0);
+	XSetWindowBorder(display, win->id,
+	    win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
+	win->got_focus = 0;
+	if (win->ws->focus == win)
+		win->ws->focus = NULL;
+	if (cur_focus == win)
+		cur_focus = NULL;
+}
+
+void
 unfocus_all(void)
 {
 	struct ws_win		*win;
@@ -928,16 +1206,8 @@ unfocus_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) {
-				if (win->ws->r == NULL)
-					continue;
-				grabbuttons(win, 0);
-				XSetWindowBorder(display, win->id,
-				    win->ws->r->s->c[SWM_S_COLOR_UNFOCUS].color);
-				win->got_focus = 0;
-				win->ws->focus = NULL;
-				cur_focus = NULL;
-			}
+			TAILQ_FOREACH(win, &screens[i].ws[j].winlist, entry)
+				unfocus_win(win);
 }
 
 void
@@ -948,7 +1218,14 @@ focus_win(struct ws_win *win)
 	if (win == NULL)
 		return;
 
-	unfocus_all();
+	if (cur_focus)
+		unfocus_win(cur_focus);
+	if (win->ws->focus) {
+		/* probably shouldn't happen due to the previous unfocus_win */
+		DNPRINTF(SWM_D_FOCUS, "unfocusing win->ws->focus: %lu\n",
+		    win->ws->focus->id);
+		unfocus_win(win->ws->focus);
+	}
 	win->ws->focus = win;
 	if (win->ws->r != NULL) {
 		cur_focus = win;
@@ -975,7 +1252,7 @@ switchws(struct swm_region *r, union arg *args)
 	old_ws = this_r->ws;
 	new_ws = &this_r->s->ws[wsid];
 
-	DNPRINTF(SWM_D_WS, "switchws screen %d region %dx%d+%d+%d: "
+	DNPRINTF(SWM_D_WS, "switchws screen[%d]:%dx%d+%d+%d: "
 	    "%d -> %d\n", r->s->idx, WIDTH(r), HEIGHT(r), X(r), Y(r),
 	    old_ws->idx, wsid);
 
@@ -986,13 +1263,14 @@ switchws(struct swm_region *r, union arg *args)
 	if (!other_r) {
 		/* if the other workspace is hidden, switch windows */
 		/* map new window first to prevent ugly blinking */
+		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);
-		old_ws->r = NULL;
-		old_ws->restack = 1;
 	} else {
 		other_r->ws = old_ws;
 		old_ws->r = other_r;
@@ -1002,6 +1280,8 @@ switchws(struct swm_region *r, union arg *args)
 
 	ignore_enter = 1;
 	/* set focus */
+	if (new_ws->focus == NULL)
+		new_ws->focus = TAILQ_FIRST(&new_ws->winlist);
 	if (new_ws->focus)
 		focus_win(new_ws->focus);
 	stack();
@@ -1015,7 +1295,7 @@ cyclews(struct swm_region *r, union arg *args)
 	struct swm_screen	*s = r->s;
 
 	DNPRINTF(SWM_D_WS, "cyclews id %d "
-	    "in screen %d region %dx%d+%d+%d ws %d\n", args->id,
+	    "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);
 
 	a.id = r->ws->idx;
@@ -1076,7 +1356,7 @@ cyclescr(struct swm_region *r, union arg *args)
 void
 swapwin(struct swm_region *r, union arg *args)
 {
-	struct ws_win		*target;
+	struct ws_win		*target, *source;
 	struct ws_win_list	*wl;
 
 
@@ -1086,40 +1366,48 @@ swapwin(struct swm_region *r, union arg *args)
 	if (cur_focus == NULL)
 		return;
 
-	wl = &cur_focus->ws->winlist;
+	source = cur_focus;
+	wl = &source->ws->winlist;
 
 	switch (args->id) {
 	case SWM_ARG_ID_SWAPPREV:
-		target = TAILQ_PREV(cur_focus, ws_win_list, entry);
+		target = TAILQ_PREV(source, ws_win_list, entry);
 		TAILQ_REMOVE(wl, cur_focus, entry);
 		if (target == NULL)
-			TAILQ_INSERT_TAIL(wl, cur_focus, entry);
+			TAILQ_INSERT_TAIL(wl, source, entry);
 		else
-			TAILQ_INSERT_BEFORE(target, cur_focus, entry);
+			TAILQ_INSERT_BEFORE(target, source, entry);
 		break;
 	case SWM_ARG_ID_SWAPNEXT: 
-		target = TAILQ_NEXT(cur_focus, entry);
-		TAILQ_REMOVE(wl, cur_focus, entry);
+		target = TAILQ_NEXT(source, entry);
+		TAILQ_REMOVE(wl, source, entry);
 		if (target == NULL)
-			TAILQ_INSERT_HEAD(wl, cur_focus, entry);
+			TAILQ_INSERT_HEAD(wl, source, entry);
 		else
-			TAILQ_INSERT_AFTER(wl, target, cur_focus, entry);
+			TAILQ_INSERT_AFTER(wl, target, source, entry);
 		break;
 	case SWM_ARG_ID_SWAPMAIN:
 		target = TAILQ_FIRST(wl);
-		if (target == cur_focus)
-			return;
+		if (target == source) {
+			if (source->ws->focus_prev != NULL &&
+			    source->ws->focus_prev != target)  
+                                
+				source = source->ws->focus_prev;
+			else
+				return;
+                }
+		source->ws->focus_prev = target;
 		TAILQ_REMOVE(wl, target, entry);
-		TAILQ_INSERT_BEFORE(cur_focus, target, entry);
-		TAILQ_REMOVE(wl, cur_focus, entry);
-		TAILQ_INSERT_HEAD(wl, cur_focus, entry);
+		TAILQ_INSERT_BEFORE(source, target, entry);
+		TAILQ_REMOVE(wl, source, entry);
+		TAILQ_INSERT_HEAD(wl, source, entry);
 		break;
 	default:
 		DNPRINTF(SWM_D_MOVE, "invalid id: %d\n", args->id);
 		return;
 	}
 
-	ignore_enter = 2;
+	ignore_enter = 1;
 	stack();
 }
 
@@ -1152,6 +1440,10 @@ focus(struct swm_region *r, union arg *args)
 
 	case SWM_ARG_ID_FOCUSMAIN:
 		winfocus = TAILQ_FIRST(wl);
+		if (winfocus == cur_focus)
+			winfocus = cur_focus->ws->focus_prev;
+		if (winfocus == NULL)
+			return;
 		break;
 
 	default:
@@ -1222,6 +1514,8 @@ stack(void) {
 			r->ws->cur_layout->l_stack(r->ws, &g);
 		}
 	}
+	if (font_adjusted)
+		font_adjusted--;
 	XSync(display, False);
 }
 
@@ -1233,8 +1527,12 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 
 	bzero(&wc, sizeof wc);
 	mask = CWX | CWY | CWBorderWidth | CWWidth | CWHeight;
-	wc.border_width = 1;
-	if (win->transient) {
+	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;
+	if (win->transient && (win->quirks & SWM_Q_TRANSSZ)) {
 		win->g.w = (double)WIDTH(r) * dialog_ratio;
 		win->g.h = (double)HEIGHT(r) * dialog_ratio;
 	}
@@ -1254,6 +1552,35 @@ stack_floater(struct ws_win *win, struct swm_region *r)
 	XConfigureWindow(display, win->id, mask, &wc);
 }
 
+/*
+ * Send keystrokes to terminal to decrease/increase the font size as the
+ * window size changes.
+ */
+void
+adjust_font(struct ws_win *win)
+{
+	if (!(win->quirks & SWM_Q_XTERM_FONTADJ) ||
+	    win->floating || win->transient)
+		return;
+	
+	if (win->sh.width_inc && win->last_inc != win->sh.width_inc &&
+	    win->g.w / win->sh.width_inc < term_width &&
+	    win->font_steps < SWM_MAX_FONT_STEPS) {
+		win->font_size_boundary[win->font_steps] =
+		    (win->sh.width_inc * term_width) + win->sh.base_width;
+		win->font_steps++;
+		font_adjusted++;
+		win->last_inc = win->sh.width_inc;
+		fake_keypress(win, XK_KP_Subtract, ShiftMask);
+	} else if (win->font_steps && win->last_inc != win->sh.width_inc &&
+	    win->g.w > win->font_size_boundary[win->font_steps - 1]) {
+		win->font_steps--;
+		font_adjusted++;
+		win->last_inc = win->sh.width_inc;
+		fake_keypress(win, XK_KP_Add, ShiftMask);
+	}
+}
+
 #define SWAPXY(g)	do {				\
 	int tmp;					\
 	tmp = (g)->y; (g)->y = (g)->x; (g)->x = tmp;	\
@@ -1265,10 +1592,11 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 	XWindowChanges		wc;
 	struct swm_geometry	win_g, r_g = *g;
 	struct ws_win		*win, *winfocus;
-	int			i, j, w_inc, h_inc, w_base, h_base;
-	int			hrh, extra, h_slice, last_h = 0;
+	int			i, j, s, stacks; 
+	int			w_inc = 1, h_inc, w_base = 1, h_base;
+	int			hrh, extra = 0, h_slice, last_h = 0;
 	int			split, colno, winno, mwin, msize, mscale;
-	int			remain, missing, v_slice;;
+	int			remain, missing, v_slice;
 	unsigned int		mask;
 
 	DNPRINTF(SWM_D_STACK, "stack_master: workspace: %d\n rot=%s flip=%s",
@@ -1281,69 +1609,84 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 		ws->focus = TAILQ_FIRST(&ws->winlist);
 	winfocus = cur_focus ? cur_focus : ws->focus;
 
-	win = TAILQ_FIRST(&ws->winlist);
+	TAILQ_FOREACH(win, &ws->winlist, entry)
+		if (win->transient == 0 && win->floating == 0)
+			break;
+
+	if (win == NULL)
+		goto notiles;
+
 	if (rot) {
 		w_inc = win->sh.width_inc;
 		w_base = win->sh.base_width;
 		mwin = ws->l_state.horizontal_mwin;
 		mscale = ws->l_state.horizontal_msize;
+		stacks = ws->l_state.horizontal_stacks;
 		SWAPXY(&r_g);
 	} else {
 		w_inc = win->sh.height_inc;
 		w_base = win->sh.base_height;
 		mwin = ws->l_state.vertical_mwin;
 		mscale = ws->l_state.vertical_msize;
+		stacks = ws->l_state.vertical_stacks;
 	}
 	win_g = r_g;
 
+	if (stacks > winno - mwin)
+		stacks = winno - mwin;
+	if (stacks < 1)
+		stacks = 1;
+
 	h_slice = r_g.h / SWM_H_SLICE;
 	if (mwin && winno > mwin) {
 		v_slice = r_g.w / SWM_V_SLICE;
 
 		split = mwin;
 		colno = split;
-		msize = v_slice * mscale;
+		win_g.w = v_slice * mscale;
 
 		if (w_inc > 1 && w_inc < v_slice) {
 			/* adjust for window's requested size increment */
 			remain = (win_g.w - w_base) % w_inc;
 			missing = w_inc - remain;
-
-			if (missing <= extra || j == 0) {
-				extra -= missing;
-				win_g.w += missing;
-			} else {
-				win_g.w -= remain;
-				extra += remain;
-			}
+			win_g.w -= remain;
+			extra += remain;
 		}
 
-		win_g.w = msize;
+		msize = win_g.w;
 		if (flip) 
 			win_g.x += r_g.w - msize;
 	} else {
-		colno = winno;
-		split = 0;
+		msize = -2;
+		colno = split = winno / stacks;
+		win_g.w = ((r_g.w - (stacks * 2) + 2) / stacks);
 	}
 	hrh = r_g.h / colno;
 	extra = r_g.h - (colno * hrh);
 	win_g.h = hrh - 2;
 
 	/*  stack all the tiled windows */
-	i = j = 0;
+	i = j = 0, s = stacks;
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
 		if (win->transient != 0 || win->floating != 0)
 			continue;
 
 		if (split && i == split) {
-			colno = winno - split;
+			colno = (winno - mwin) / stacks;
+			if (s <= (winno - mwin) % stacks)
+				colno++;
+			split = split + colno;
 			hrh = (r_g.h / colno);
 			extra = r_g.h - (colno * hrh);
 			if (flip)
 				win_g.x = r_g.x;
 			else
-				win_g.x += msize + 2;
-			win_g.w = r_g.w - (msize + 2);
+				win_g.x += win_g.w + 2;
+			win_g.w = (r_g.w - msize - (stacks * 2)) / stacks;
+			if (s == 1)
+				win_g.w += (r_g.w - msize - (stacks * 2)) %
+				    stacks;
+			s--;
 			j = 0;
 		}
 		win_g.h = hrh - 2;
@@ -1351,7 +1694,7 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 			h_inc = win->sh.width_inc;
 			h_base = win->sh.base_width;
 		} else {
-		   	h_inc =	win->sh.height_inc;	
+		   	h_inc =	win->sh.height_inc;
 			h_base = win->sh.base_height;
 		}
 		if (j == colno - 1) {
@@ -1388,18 +1731,17 @@ stack_master(struct workspace *ws, struct swm_geometry *g, int rot, int flip)
 			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);
-		/*
-		fprintf(stderr, "vertical_stack: win %d x %d y %d w %d h %d bw %d\n", win->id, win->g.x, win->g.y, win->g.w , win->g.h, wc.border_width);
-		*/
 
 		last_h = win_g.h;
 		i++;
 		j++;
 	}
 
+ notiles:
 	/* now, stack all the floaters and transients */
 	TAILQ_FOREACH(win, &ws->winlist, entry) {
 		if (win->transient == 0 && win->floating == 0)
@@ -1423,6 +1765,7 @@ vertical_config(struct workspace *ws, int id)
 	case SWM_ARG_ID_STACKINIT:
 		ws->l_state.vertical_msize = SWM_V_SLICE / 2;
 		ws->l_state.vertical_mwin = 1;
+		ws->l_state.vertical_stacks = 1;
 		break;
 	case SWM_ARG_ID_MASTERSHRINK:
 		if (ws->l_state.vertical_msize > 1)
@@ -1439,6 +1782,13 @@ vertical_config(struct workspace *ws, int id)
 		if (ws->l_state.vertical_mwin > 0)
 			ws->l_state.vertical_mwin--;
 		break;
+	case SWM_ARG_ID_STACKINC:
+		ws->l_state.vertical_stacks++;
+		break;
+	case SWM_ARG_ID_STACKDEC:
+		if (ws->l_state.vertical_stacks > 1)
+			ws->l_state.vertical_stacks--;
+		break;
 	default:
 		return;
 	}
@@ -1462,6 +1812,7 @@ horizontal_config(struct workspace *ws, int id)
 	case SWM_ARG_ID_STACKINIT:
 		ws->l_state.horizontal_mwin = 1;
 		ws->l_state.horizontal_msize = SWM_H_SLICE / 2;
+		ws->l_state.horizontal_stacks = 1;
 		break;
 	case SWM_ARG_ID_MASTERSHRINK:
 		if (ws->l_state.horizontal_msize > 1)
@@ -1478,6 +1829,13 @@ horizontal_config(struct workspace *ws, int id)
 		if (ws->l_state.horizontal_mwin > 0)
 			ws->l_state.horizontal_mwin--;
 		break;
+	case SWM_ARG_ID_STACKINC:
+		ws->l_state.horizontal_stacks++;
+		break;
+	case SWM_ARG_ID_STACKDEC:
+		if (ws->l_state.horizontal_stacks > 1)
+			ws->l_state.horizontal_stacks--;
+		break;
 	default:
 		return;
 	}
@@ -1589,9 +1947,16 @@ send_to_ws(struct swm_region *r, union arg *args)
 void
 wkill(struct swm_region *r, union arg *args)
 {
-	DNPRINTF(SWM_D_MISC, "wkill\n");
-	if(r->ws->focus != NULL)
+	DNPRINTF(SWM_D_MISC, "wkill %d\n", args->id);
+
+	if(r->ws->focus == NULL)
+		return;
+
+	if (args->id == SWM_ARG_ID_KILLWINDOW)
 		XKillClient(display, r->ws->focus->id);
+	else
+		if (r->ws->focus->can_delete)
+			client_msg(r->ws->focus, adelete);
 }
 
 void
@@ -1632,65 +1997,6 @@ floating_toggle(struct swm_region *r, union arg *args)
 	focus_win(win);
 }
 
-/* key definitions */
-struct key {
-	unsigned int		mod;
-	KeySym			keysym;
-	void			(*func)(struct swm_region *r, union arg *);
-	union arg		args;
-} keys[] = {
-	/* modifier		key	function		argument */
-	{ MODKEY,		XK_space,	cycle_layout,	{0} }, 
-	{ MODKEY | ShiftMask,	XK_space,	stack_config,	{.id = SWM_ARG_ID_STACKRESET} }, 
-	{ MODKEY,		XK_h,		stack_config,	{.id = SWM_ARG_ID_MASTERSHRINK} },
-	{ MODKEY,		XK_l,		stack_config,	{.id = SWM_ARG_ID_MASTERGROW} },
-	{ MODKEY,		XK_comma,	stack_config,	{.id = SWM_ARG_ID_MASTERADD} },
-	{ MODKEY,		XK_period,	stack_config,	{.id = SWM_ARG_ID_MASTERDEL} },
-	{ MODKEY,		XK_Return,	swapwin,	{.id = SWM_ARG_ID_SWAPMAIN} },
-	{ MODKEY,		XK_j,		focus,		{.id = SWM_ARG_ID_FOCUSNEXT} },
-	{ MODKEY,		XK_k,		focus,		{.id = SWM_ARG_ID_FOCUSPREV} },
-	{ MODKEY | ShiftMask,	XK_j,		swapwin,	{.id = SWM_ARG_ID_SWAPNEXT} },
-	{ MODKEY | ShiftMask,	XK_k,		swapwin,	{.id = SWM_ARG_ID_SWAPPREV} },
-	{ MODKEY | ShiftMask,	XK_Return,	spawn,		{.argv = spawn_term} },
-	{ MODKEY,		XK_p,		spawnmenu,	{.argv = spawn_menu} },
-	{ MODKEY | ShiftMask,	XK_q,		quit,		{0} },
-	{ MODKEY,		XK_q,		restart,	{0} },
-	{ MODKEY,		XK_m,		focus,		{.id = SWM_ARG_ID_FOCUSMAIN} },
-	{ MODKEY,		XK_1,		switchws,	{.id = 0} },
-	{ MODKEY,		XK_2,		switchws,	{.id = 1} },
-	{ MODKEY,		XK_3,		switchws,	{.id = 2} },
-	{ MODKEY,		XK_4,		switchws,	{.id = 3} },
-	{ MODKEY,		XK_5,		switchws,	{.id = 4} },
-	{ MODKEY,		XK_6,		switchws,	{.id = 5} },
-	{ MODKEY,		XK_7,		switchws,	{.id = 6} },
-	{ MODKEY,		XK_8,		switchws,	{.id = 7} },
-	{ MODKEY,		XK_9,		switchws,	{.id = 8} },
-	{ MODKEY,		XK_0,		switchws,	{.id = 9} },
-	{ MODKEY,		XK_Right,	cyclews,	{.id = SWM_ARG_ID_CYCLEWS_UP} }, 
-	{ MODKEY,		XK_Left,	cyclews,	{.id = SWM_ARG_ID_CYCLEWS_DOWN} }, 
-	{ MODKEY | ShiftMask,	XK_Right,	cyclescr,	{.id = SWM_ARG_ID_CYCLESC_UP} }, 
-	{ MODKEY | ShiftMask,	XK_Left,	cyclescr,	{.id = SWM_ARG_ID_CYCLESC_DOWN} }, 
-	{ MODKEY | ShiftMask,	XK_1,		send_to_ws,	{.id = 0} },
-	{ MODKEY | ShiftMask,	XK_2,		send_to_ws,	{.id = 1} },
-	{ MODKEY | ShiftMask,	XK_3,		send_to_ws,	{.id = 2} },
-	{ MODKEY | ShiftMask,	XK_4,		send_to_ws,	{.id = 3} },
-	{ MODKEY | ShiftMask,	XK_5,		send_to_ws,	{.id = 4} },
-	{ MODKEY | ShiftMask,	XK_6,		send_to_ws,	{.id = 5} },
-	{ MODKEY | ShiftMask,	XK_7,		send_to_ws,	{.id = 6} },
-	{ MODKEY | ShiftMask,	XK_8,		send_to_ws,	{.id = 7} },
-	{ MODKEY | ShiftMask,	XK_9,		send_to_ws,	{.id = 8} },
-	{ MODKEY | ShiftMask,	XK_0,		send_to_ws,	{.id = 9} },
-	{ MODKEY,		XK_b,		bar_toggle,	{0} },
-	{ MODKEY,		XK_Tab,		focus,		{.id = SWM_ARG_ID_FOCUSNEXT} },
-	{ MODKEY | ShiftMask,	XK_Tab,		focus,		{.id = SWM_ARG_ID_FOCUSPREV} },
-	{ MODKEY | ShiftMask,	XK_x,		wkill,		{0} },
-	{ MODKEY,		XK_s,		screenshot,	{.id = SWM_ARG_ID_SS_ALL} },
-	{ MODKEY | ShiftMask,	XK_s,		screenshot,	{.id = SWM_ARG_ID_SS_WINDOW} },
-	{ MODKEY,		XK_t,		floating_toggle,{0} },
-	{ MODKEY | ShiftMask,	XK_v,		version,	{0} },
-	{ MODKEY | ShiftMask,	XK_Delete,	spawn,		{.argv = spawn_lock} },
-};
-
 void
 resize_window(struct ws_win *win, int center)
 {
@@ -1723,7 +2029,7 @@ resize(struct ws_win *win, union arg *args)
 	XEvent			ev;
 	Time			time = 0;
 
-	DNPRINTF(SWM_D_MOUSE, "resize: win %d floating %d trans %d\n",
+	DNPRINTF(SWM_D_MOUSE, "resize: win %lu floating %d trans %d\n",
 	    win->id, win->floating, win->transient);
 
 	if (!(win->transient != 0 || win->floating != 0))
@@ -1743,10 +2049,10 @@ resize(struct ws_win *win, union arg *args)
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
-			if (ev.xmotion.x < 0)
-				ev.xmotion.x = 0;
-			if (ev.xmotion.y < 0)
-				ev.xmotion.y = 0;
+			if (ev.xmotion.x <= 1)
+				ev.xmotion.x = 1;
+			if (ev.xmotion.y <= 1)
+				ev.xmotion.y = 1;
 			win->g.w = ev.xmotion.x;
 			win->g.h = ev.xmotion.y;
 
@@ -1798,7 +2104,7 @@ move(struct ws_win *win, union arg *args)
 	Time			time = 0;
 	int			restack = 0;
 
-	DNPRINTF(SWM_D_MOUSE, "move: win %d floating %d trans %d\n",
+	DNPRINTF(SWM_D_MOUSE, "move: win %lu floating %d trans %d\n",
 	    win->id, win->floating, win->transient);
 
 	if (win->floating == 0) {
@@ -1846,6 +2152,73 @@ move(struct ws_win *win, union arg *args)
 	while (XCheckMaskEvent(display, EnterWindowMask, &ev));
 }
 
+/* key definitions */
+struct keyfunc {
+	char			name[SWM_FUNCNAME_LEN];
+	void			(*func)(struct swm_region *r, union arg *);
+	union arg		args;
+} keyfuncs[kf_invalid] = {
+	/* name			function	argument */
+	{ "cycle_layout",	cycle_layout,	{0} }, 
+	{ "stack_reset",	stack_config,	{.id = SWM_ARG_ID_STACKRESET} }, 
+	{ "master_shrink",	stack_config,	{.id = SWM_ARG_ID_MASTERSHRINK} },
+	{ "master_grow",	stack_config,	{.id = SWM_ARG_ID_MASTERGROW} },
+	{ "master_add",		stack_config,	{.id = SWM_ARG_ID_MASTERADD} },
+	{ "master_del",		stack_config,	{.id = SWM_ARG_ID_MASTERDEL} },
+	{ "stack_inc",		stack_config,	{.id = SWM_ARG_ID_STACKINC} },
+	{ "stack_dec",		stack_config,	{.id = SWM_ARG_ID_STACKDEC} },
+	{ "swap_main",		swapwin,	{.id = SWM_ARG_ID_SWAPMAIN} },
+	{ "focus_next",		focus,		{.id = SWM_ARG_ID_FOCUSNEXT} },
+	{ "focus_prev",		focus,		{.id = SWM_ARG_ID_FOCUSPREV} },
+	{ "swap_next",		swapwin,	{.id = SWM_ARG_ID_SWAPNEXT} },
+	{ "swap_prev",		swapwin,	{.id = SWM_ARG_ID_SWAPPREV} },
+	{ "spawn_term",		spawnterm,	{.argv = spawn_term} },
+	{ "spawn_menu",		spawnmenu,	{.argv = spawn_menu} },
+	{ "quit",		quit,		{0} },
+	{ "restart",		restart,	{0} },
+	{ "focus_main",		focus,		{.id = SWM_ARG_ID_FOCUSMAIN} },
+	{ "ws_1",		switchws,	{.id = 0} },
+	{ "ws_2",		switchws,	{.id = 1} },
+	{ "ws_3",		switchws,	{.id = 2} },
+	{ "ws_4",		switchws,	{.id = 3} },
+	{ "ws_5",		switchws,	{.id = 4} },
+	{ "ws_6",		switchws,	{.id = 5} },
+	{ "ws_7",		switchws,	{.id = 6} },
+	{ "ws_8",		switchws,	{.id = 7} },
+	{ "ws_9",		switchws,	{.id = 8} },
+	{ "ws_10",		switchws,	{.id = 9} },
+	{ "ws_next",		cyclews,	{.id = SWM_ARG_ID_CYCLEWS_UP} }, 
+	{ "ws_prev",		cyclews,	{.id = SWM_ARG_ID_CYCLEWS_DOWN} }, 
+	{ "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} },
+	{ "mvws_2",		send_to_ws,	{.id = 1} },
+	{ "mvws_3",		send_to_ws,	{.id = 2} },
+	{ "mvws_4",		send_to_ws,	{.id = 3} },
+	{ "mvws_5",		send_to_ws,	{.id = 4} },
+	{ "mvws_6",		send_to_ws,	{.id = 5} },
+	{ "mvws_7",		send_to_ws,	{.id = 6} },
+	{ "mvws_8",		send_to_ws,	{.id = 7} },
+	{ "mvws_9",		send_to_ws,	{.id = 8} },
+	{ "mvws_10",		send_to_ws,	{.id = 9} },
+	{ "bar_toggle",		bar_toggle,	{0} },
+	{ "wind_kill",		wkill,		{.id = SWM_ARG_ID_KILLWINDOW} },
+	{ "wind_del",		wkill,		{.id = SWM_ARG_ID_DELETEWINDOW} },
+	{ "screenshot_all",	screenshot,	{.id = SWM_ARG_ID_SS_ALL} },
+	{ "screenshot_wind",	screenshot,	{.id = SWM_ARG_ID_SS_WINDOW} },
+	{ "float_toggle",	floating_toggle,{0} },
+	{ "version",		version,	{0} },
+	{ "spawn_lock",		spawn,		{.argv = spawn_lock} },
+	{ "spawn_initscr",	spawn,		{.argv = spawn_initscr} },
+};
+struct key {
+	unsigned int		mod;
+	KeySym			keysym;
+	enum keyfuncid		funcid;
+};
+int				keys_size = 0, keys_length = 0;
+struct key			*keys = NULL;
+
 /* mouse */
 enum { client_click, root_click };
 struct button {
@@ -1862,6 +2235,225 @@ struct button {
 };
 
 void
+update_modkey(unsigned int mod)
+{
+	int			i;
+
+	for (i = 0; i < keys_length; i++)
+		if (keys[i].mod & ShiftMask)
+			keys[i].mod = mod | ShiftMask;
+		else
+			keys[i].mod = mod;
+
+	for (i = 0; i < LENGTH(buttons); i++)
+		if (buttons[i].mask & ShiftMask)
+			buttons[i].mask = mod | ShiftMask;
+		else
+			buttons[i].mask = mod;
+}
+
+#define SWM_MODNAME_SIZE	32
+#define	SWM_KEY_WS		"\n+ \t"
+int
+parsekeys(char *keystr, unsigned int currmod, unsigned int *mod, KeySym *ks)
+{
+	char			*cp, *name;
+	KeySym			uks;
+	if (mod == NULL || ks == NULL)
+		return (0);
+	cp = keystr;
+	*mod = 0;
+	while ((name = strsep(&cp, SWM_KEY_WS)) != NULL) {
+		if (cp)
+			cp += (long)strspn(cp, SWM_KEY_WS);
+		if (strncasecmp(name, "MOD", SWM_MODNAME_SIZE) == 0)
+			*mod |= currmod;
+		else if (!strncasecmp(name, "Mod1", SWM_MODNAME_SIZE))
+			*mod |= Mod1Mask;
+		else if (!strncasecmp(name, "Mod2", SWM_MODNAME_SIZE))
+			*mod += Mod2Mask;
+		else if (!strncmp(name, "Mod3", SWM_MODNAME_SIZE))
+			*mod |= Mod3Mask;
+		else if (!strncmp(name, "Mod4", SWM_MODNAME_SIZE))
+			*mod |= Mod4Mask;
+		else if (strncasecmp(name, "SHIFT", SWM_MODNAME_SIZE) == 0)
+			*mod |= ShiftMask;
+		else if (strncasecmp(name, "CONTROL", SWM_MODNAME_SIZE) == 0)
+			*mod |= ControlMask;
+		else {
+			*ks = XStringToKeysym(name);
+			XConvertCase(*ks, ks, &uks);
+			if (ks == NoSymbol) {
+				DNPRINTF(SWM_D_KEY,
+				    "parsekeys: invalid key %s\n",
+				    name);
+				return (0);
+			}
+		}
+	}
+	return (1);
+}
+int
+bindmatch(const char *var, const char *name, unsigned int currmod, char *keystr,
+    enum keyfuncid *kfid, unsigned int *mod, KeySym *ks)
+{
+	char			*p;
+	int 			i;
+	char			funcname[SWM_FUNCNAME_LEN];
+	i = strncmp(var, name, 255);
+	if (kfid == NULL || mod == NULL || ks == NULL)
+		return (i);
+	*kfid = kf_invalid;
+	*mod = 0;
+	*ks = NoSymbol;
+	bzero(funcname, LENGTH(funcname));
+	if (i <= 0)
+		return (i);
+	p = (char *)var + strlen(name);
+	if (*p++ != '[')
+		return (i);
+	i = 0;
+	while (isgraph(*p) && *p != ']' && i < LENGTH(funcname))
+		funcname[i++] = *p++;
+	if (i >= LENGTH(funcname) || *p != ']')
+		return (1);
+	if (i == 0)
+		return (!parsekeys(keystr, currmod, mod, ks));
+	for (*kfid = 0; *kfid < kf_invalid; (*kfid)++) {
+		if (strncasecmp(funcname, keyfuncs[*kfid].name,
+		    SWM_FUNCNAME_LEN) == 0) {
+			return (!parsekeys(keystr, currmod, mod, ks));
+		}
+
+	}
+	return (1);
+}
+void
+setkeybinding(unsigned int mod, KeySym ks, enum keyfuncid kfid)
+{
+	int			i, j;
+	/* find existing */
+	for (i = 0; i < keys_length; i++) {
+		if (keys[i].mod == mod && keys[i].keysym == ks) {
+			if (kfid == kf_invalid) {
+				/* found: delete */
+				DNPRINTF(SWM_D_KEY,
+				    "setkeybinding: delete #%d %s\n",
+				    i, keyfuncs[keys[i].funcid].name);
+				j = keys_length - 1;
+				if (i < j)
+					keys[i] = keys[j];
+				keys_length--;
+				return;
+			} else {
+				/* found: replace */
+				DNPRINTF(SWM_D_KEY,
+				    "setkeybinding: replace #%d %s\n",
+				    i, keyfuncs[keys[i].funcid].name);
+				keys[i].mod = mod;
+				keys[i].keysym = ks;
+				keys[i].funcid = kfid;
+				return;
+			}
+		}
+	}
+	if (kfid == kf_invalid) {
+		fprintf(stderr,
+		    "error: setkeybinding: cannot find mod/key combination");
+		return;
+	}
+	/* not found: add */
+	if (keys_size == 0 || keys == NULL) {
+		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) {
+			fprintf(stderr, "malloc failed\n");
+			perror(" failed");
+			quit(NULL, NULL);
+		}
+	} else if (keys_length == keys_size) {
+		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) {
+			fprintf(stderr, "realloc failed\n");
+			perror(" failed");
+			quit(NULL, NULL);
+		}
+	}
+	if (keys_length < keys_size) {
+		DNPRINTF(SWM_D_KEY, "setkeybinding: add %d\n", keys_length);
+		j = keys_length++;
+		keys[j].mod = mod;
+		keys[j].keysym = ks;
+		keys[j].funcid = kfid;
+	} else {
+		fprintf(stderr, "keys array problem?\n");
+		if (!keys) {
+			fprintf(stderr, "keys array problem\n");
+			quit(NULL, NULL);
+		}
+	}
+}
+void
+setup_keys(void)
+{
+	setkeybinding(MODKEY,		XK_space,	kf_cycle_layout); 
+	setkeybinding(MODKEY|ShiftMask,	XK_space,	kf_stack_reset);
+	setkeybinding(MODKEY,		XK_h,		kf_master_shrink);
+	setkeybinding(MODKEY,		XK_l,		kf_master_grow);
+	setkeybinding(MODKEY,		XK_comma,	kf_master_add);
+	setkeybinding(MODKEY,		XK_period,	kf_master_del);
+	setkeybinding(MODKEY|ShiftMask,	XK_comma,	kf_stack_inc);
+	setkeybinding(MODKEY|ShiftMask,	XK_period,	kf_stack_dec);
+	setkeybinding(MODKEY,		XK_Return,	kf_swap_main);
+	setkeybinding(MODKEY,		XK_j,		kf_focus_next);
+	setkeybinding(MODKEY,		XK_k,		kf_focus_prev);
+	setkeybinding(MODKEY|ShiftMask,	XK_j,		kf_swap_next);
+	setkeybinding(MODKEY|ShiftMask,	XK_k,		kf_swap_prev);
+	setkeybinding(MODKEY|ShiftMask,	XK_Return,	kf_spawn_term);
+	setkeybinding(MODKEY,		XK_p,		kf_spawn_menu);
+	setkeybinding(MODKEY|ShiftMask,	XK_q,		kf_quit);
+	setkeybinding(MODKEY,		XK_q,		kf_restart);
+	setkeybinding(MODKEY,		XK_m,		kf_focus_main);
+	setkeybinding(MODKEY,		XK_1,		kf_ws_1);
+	setkeybinding(MODKEY,		XK_2,		kf_ws_2);
+	setkeybinding(MODKEY,		XK_3,		kf_ws_3);
+	setkeybinding(MODKEY,		XK_4,		kf_ws_4);
+	setkeybinding(MODKEY,		XK_5,		kf_ws_5);
+	setkeybinding(MODKEY,		XK_6,		kf_ws_6);
+	setkeybinding(MODKEY,		XK_7,		kf_ws_7);
+	setkeybinding(MODKEY,		XK_8,		kf_ws_8);
+	setkeybinding(MODKEY,		XK_9,		kf_ws_9);
+	setkeybinding(MODKEY,		XK_0,		kf_ws_10);
+	setkeybinding(MODKEY,		XK_Right,	kf_ws_next);
+	setkeybinding(MODKEY,		XK_Left,	kf_ws_prev);
+	setkeybinding(MODKEY|ShiftMask,	XK_Right,	kf_screen_next);
+	setkeybinding(MODKEY|ShiftMask,	XK_Left,	kf_screen_prev);
+	setkeybinding(MODKEY|ShiftMask,	XK_1,		kf_mvws_1);
+	setkeybinding(MODKEY|ShiftMask,	XK_2,		kf_mvws_2);
+	setkeybinding(MODKEY|ShiftMask,	XK_3,		kf_mvws_3);
+	setkeybinding(MODKEY|ShiftMask,	XK_4,		kf_mvws_4);
+	setkeybinding(MODKEY|ShiftMask,	XK_5,		kf_mvws_5);
+	setkeybinding(MODKEY|ShiftMask,	XK_6,		kf_mvws_6);
+	setkeybinding(MODKEY|ShiftMask,	XK_7,		kf_mvws_7);
+	setkeybinding(MODKEY|ShiftMask,	XK_8,		kf_mvws_8);
+	setkeybinding(MODKEY|ShiftMask,	XK_9,		kf_mvws_9);
+	setkeybinding(MODKEY|ShiftMask,	XK_0,		kf_mvws_10);
+	setkeybinding(MODKEY,		XK_b,		kf_bar_toggle);
+	setkeybinding(MODKEY,		XK_Tab,		kf_focus_next);
+	setkeybinding(MODKEY|ShiftMask,	XK_Tab,		kf_focus_prev);
+	setkeybinding(MODKEY|ShiftMask,	XK_x,		kf_wind_kill);
+	setkeybinding(MODKEY,		XK_x,		kf_wind_del);
+	setkeybinding(MODKEY,		XK_s,		kf_screenshot_all);
+	setkeybinding(MODKEY|ShiftMask,	XK_s,		kf_screenshot_wind);
+	setkeybinding(MODKEY,		XK_t,		kf_float_toggle);
+	setkeybinding(MODKEY|ShiftMask,	XK_v,		kf_version);
+	setkeybinding(MODKEY|ShiftMask,	XK_Delete,	kf_spawn_lock);
+	setkeybinding(MODKEY|ShiftMask,	XK_i,		kf_spawn_initscr);
+}
+void
 updatenumlockmask(void)
 {
 	unsigned int		i, j;
@@ -1894,7 +2486,7 @@ grabkeys(void)
 		if (TAILQ_EMPTY(&screens[k].rl))
 			continue;
 		XUngrabKey(display, AnyKey, AnyModifier, screens[k].root);
-		for (i = 0; i < LENGTH(keys); i++) {
+		for (i = 0; i < keys_length; i++) {
 			if ((code = XKeysymToKeycode(display, keys[i].keysym)))
 				for (j = 0; j < LENGTH(modifiers); j++)
 					XGrabKey(display, code,
@@ -1944,12 +2536,14 @@ keypress(XEvent *e)
 	DNPRINTF(SWM_D_EVENT, "keypress: window: %lu\n", ev->window);
 
 	keysym = XKeycodeToKeysym(display, (KeyCode)ev->keycode, 0);
-	for (i = 0; i < LENGTH(keys); i++)
+	for (i = 0; i < keys_length; i++)
 		if (keysym == keys[i].keysym
 		   && CLEANMASK(keys[i].mod) == CLEANMASK(ev->state)
-		   && keys[i].func)
-			keys[i].func(root_to_region(ev->root),
-			    &(keys[i].args));
+		   && keyfuncs[keys[i].funcid].func)
+			keyfuncs[keys[i].funcid].func(
+			    root_to_region(ev->root),
+			    &(keyfuncs[keys[i].funcid].args)
+			    );
 }
 
 void
@@ -1988,19 +2582,191 @@ set_win_state(struct ws_win *win, long state)
 	    (unsigned char *)data, 2);
 }
 
+const char *quirkname[] = {
+	"NONE",		/* config string for "no value" */
+	"FLOAT",
+	"TRANSSZ",
+	"ANYWHERE",
+	"XTERM_FONTADJ",
+	"FULLSCREEN",
+};
+
+#define	SWM_Q_WS		"\n| \t"
+int
+parsequirks(char *qstr, unsigned long *quirk)
+{
+	char			*cp, *name;
+	int			i;
+	if (quirk == NULL)
+		return (0);
+	cp = qstr;
+	*quirk = 0;
+	while ((name = strsep(&cp, SWM_Q_WS)) != NULL) {
+		if (cp)
+			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);
+				if (i == 0) {
+					*quirk = 0;
+					return (1);
+				}
+				*quirk |= 1 << (i-1);
+				break;
+			}
+		}
+		if (i >= LENGTH(quirkname)) {
+			DNPRINTF(SWM_D_QUIRK,
+			    "parsequirks: invalid quirk [%s]\n", name);
+			return (0);
+		}
+	}
+	return (1);
+}
+int
+quirkmatch(const char *var, const char *name, char *qstr, char *qclass,
+    char *qname, unsigned long *qquirk)
+{
+	char			*p;
+	int 			i;
+	char			classname[SWM_QUIRK_LEN*2+1];
+	DNPRINTF(SWM_D_QUIRK, "quirkmatch: in [%s]\n", var);
+	i = strncmp(var, name, 255);
+	if (qclass == NULL || qname == NULL || qquirk == NULL)
+		return (i);
+	*qquirk = 0;
+	*qclass = '\0';
+	*qname  = '\0';
+	bzero(classname, LENGTH(classname));
+	if (i <= 0)
+		return (i);
+	p = (char *)var + strlen(name);
+	if (*p++ != '[')
+		return (i);
+	i = 0;
+	while (isgraph(*p) && *p != ']' && i < LENGTH(classname))
+		classname[i++] = *p++;
+	if (i >= LENGTH(classname) || *p != ']')
+		return (1);
+	if ((p = strchr(classname, ':')) == NULL || p-classname >= SWM_QUIRK_LEN)
+		return (1);
+	strlcpy(qclass, classname, p-classname+1);
+	strlcpy(qname, ++p, SWM_QUIRK_LEN);
+	for (p = qclass; *p && p-qclass < SWM_QUIRK_LEN; p++)
+		if (*p == '_')
+			*p = ' ';
+	for (p = qname; *p && p-qname < SWM_QUIRK_LEN; p++)
+		if (*p == '_')
+			*p = ' ';
+	i = (!parsequirks(qstr, qquirk));
+	DNPRINTF(SWM_D_QUIRK, "quirkmatch: [%s][%s] %d\n", qclass, qname, i);
+	return (i);
+}
+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) &&
+		    !strcmp(quirks[i].name, name)) {
+			if (!quirk) {
+				/* found: delete */
+				DNPRINTF(SWM_D_QUIRK,
+				    "setquirk: delete #%d %s:%s\n",
+				    i, quirks[i].class, quirks[i].name);
+				j = quirks_length - 1;
+				if (i < j)
+					quirks[i] = quirks[j];
+				quirks_length--;
+				return;
+			} else {
+				/* found: replace */
+				DNPRINTF(SWM_D_QUIRK,
+				    "setquirk: replace #%d %s:%s\n",
+				    i, quirks[i].class, quirks[i].name);
+				strlcpy(quirks[i].class, class,
+				    sizeof quirks->class);
+				strlcpy(quirks[i].name, name,
+				    sizeof quirks->name);
+				quirks[i].quirk = quirk;
+				return;
+			}
+		}
+	}
+	if (!quirk) {
+		fprintf(stderr,
+		    "error: setquirk: cannot find class/name combination");
+		return;
+	}
+	/* not found: add */
+	if (quirks_size == 0 || quirks == NULL) {
+		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) {
+			fprintf(stderr, "setquirk: malloc failed\n");
+			perror(" failed");
+			quit(NULL, NULL);
+		}
+	} 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) {
+			fprintf(stderr, "setquirk: realloc failed\n");
+			perror(" failed");
+			quit(NULL, NULL);
+		}
+	}
+	if (quirks_length < quirks_size) {
+		DNPRINTF(SWM_D_QUIRK, "setquirk: add %d\n", quirks_length);
+		j = quirks_length++;
+		strlcpy(quirks[j].class, class, sizeof quirks->class);
+		strlcpy(quirks[j].name, name, sizeof quirks->name);
+		quirks[j].quirk = quirk;
+	} else {
+		fprintf(stderr, "quirks array problem?\n");
+		if (!quirks) {
+			fprintf(stderr, "quirks array problem!\n");
+			quit(NULL, NULL);
+		}
+	}
+}
+
+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("Firefox-bin",		"firefox-bin",	SWM_Q_TRANSSZ);
+	setquirk("Firefox",		"Dialog",	SWM_Q_FLOAT);
+	setquirk("Gimp",		"gimp",		SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+	setquirk("XTerm",		"xterm",	SWM_Q_XTERM_FONTADJ);
+	setquirk("xine",		"Xine Window",	SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+	setquirk("Xitk",		"Xitk Combo",	SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+	setquirk("xine",		"xine Panel",	SWM_Q_FLOAT | SWM_Q_ANYWHERE);
+	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);
+}
+
 struct ws_win *
 manage_window(Window id)
 {
 	Window			trans;
 	struct workspace	*ws;
 	struct ws_win		*win;
-	int			format, i, ws_idx;
+	int			format, i, ws_idx, n;
 	unsigned long		nitems, bytes;
 	Atom			ws_idx_atom = 0, type;
+	Atom			*prot = NULL, *pp;
 	unsigned char		ws_idx_str[SWM_PROPLEN], *prop = NULL;
 	struct swm_region	*r;
 	long			mask;
 	const char		*errstr;
+	XWindowChanges		wc;
 
 	if ((win = find_window(id)) != NULL)
 			return (win);	/* already being managed */
@@ -2021,7 +2787,15 @@ manage_window(Window id)
 		DNPRINTF(SWM_D_MISC, "manage_window: win %u transient %u\n",
 		    (unsigned)win->id, win->transient);
 	}
-	
+	/* get supported protocols */
+	if (XGetWMProtocols(display, id, &prot, &n)) {
+		for (i = 0, pp = prot; i < n; i++, pp++)
+			if (*pp == adelete)
+				win->can_delete = 1;
+		if (prot)
+			XFree(prot);
+	}
+
 	/*
 	 * Figure out where to put the window. If it was previously assigned to
 	 * a workspace (either by spawn() or manually moving), and isn't
@@ -2060,30 +2834,56 @@ manage_window(Window id)
 	}
 	XFree(prop);
 
-	/*
-	fprintf(stderr, "manage window: %d x %d y %d w %d h %d\n", win->id, win->g.x, win->g.y, win->g.w, win->g.h);
-	*/
-
 	if (XGetClassHint(display, win->id, &win->ch)) {
 		DNPRINTF(SWM_D_CLASS, "class: %s name: %s\n",
 		    win->ch.res_class, win->ch.res_name);
-		for (i = 0; quirks[i].class != NULL && quirks[i].name != NULL &&
-		    quirks[i].quirk != 0; i++){
+		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)
 					win->floating = 1;
+				win->quirks = quirks[i].quirk;
 			}
 		}
 	}
 
+	/* alter window position if quirky */
+	if (win->quirks & SWM_Q_ANYWHERE) {
+		win->manual = 1; /* don't center the quirky windows */
+		bzero(&wc, sizeof wc);
+		mask = 0;
+		if (win->g.y < bar_height) {
+			win->g.y = wc.y = bar_height;
+			mask |= CWY;
+		}
+		if (win->g.w + win->g.x > WIDTH(r)) {
+			win->g.x = wc.x = WIDTH(win->ws->r) - win->g.w - 2;
+			mask |= CWX;
+		}
+		wc.border_width = 1;
+		mask |= CWBorderWidth;
+		XConfigureWindow(display, win->id, mask, &wc);
+	}
+
+	/* Reset font sizes (the bruteforce way; no default keybinding). */
+	if (win->quirks & SWM_Q_XTERM_FONTADJ) {
+		for (i = 0; i < SWM_MAX_FONT_STEPS; i++)
+			fake_keypress(win, XK_KP_Subtract, ShiftMask);
+		for (i = 0; i < SWM_MAX_FONT_STEPS; i++)
+			fake_keypress(win, XK_KP_Add, ShiftMask);
+	}
+
 	XSelectInput(display, id, EnterWindowMask | FocusChangeMask |
 	    PropertyChangeMask | StructureNotifyMask);
 
 	set_win_state(win, NormalState);
 
+	/* floaters need to be mapped if they are in the current workspace */
+	if (win->floating && (ws->idx == r->ws->idx))
+		XMapRaised(display, win->id);
+
 	/* make new win focused */
 	focus_win(win);
 
@@ -2091,6 +2891,43 @@ manage_window(Window id)
 }
 
 void
+unmanage_window(struct ws_win *win)
+{
+	struct workspace	*ws;
+
+	if (win == NULL)
+		return;
+
+	DNPRINTF(SWM_D_MISC, "unmanage_window:  %lu\n", win->id);
+
+	/* don't unmanage if we are switching workspaces */
+	ws = win->ws;
+	if (ws->restack)
+		return;
+
+	/* find a window to focus */
+	if (ws->focus == win)
+		ws->focus = TAILQ_PREV(win, ws_win_list, entry);
+	if (ws->focus == NULL)
+		ws->focus = TAILQ_FIRST(&ws->winlist);
+	if (ws->focus == NULL || ws->focus == win) {
+		ws->focus = NULL;
+		unfocus_win(win);
+	} else
+		focus_win(ws->focus);
+	if (ws->focus_prev == win)
+		ws->focus_prev = NULL;
+
+	TAILQ_REMOVE(&win->ws->winlist, win, entry);
+	set_win_state(win, WithdrawnState);
+	if (win->ch.res_class)
+		XFree(win->ch.res_class);
+	if (win->ch.res_name)
+		XFree(win->ch.res_name);
+	free(win);
+}
+
+void
 configurerequest(XEvent *e)
 {
 	XConfigureRequestEvent	*ev = &e->xconfigurerequest;
@@ -2104,10 +2941,6 @@ configurerequest(XEvent *e)
 	if (new) {
 		DNPRINTF(SWM_D_EVENT, "configurerequest: new window: %lu\n",
 		    ev->window);
-		/*
-		fprintf(stderr, "configurerequest: new window: %lu x %d y %d w %d h %d bw %d s %d sm %d\n",
-		    ev->window, ev->x, ev->y, ev->width, ev->height, ev->border_width, ev->above, ev->detail);
-		*/
 		bzero(&wc, sizeof wc);
 		wc.x = ev->x;
 		wc.y = ev->y;
@@ -2118,10 +2951,6 @@ configurerequest(XEvent *e)
 		wc.stack_mode = ev->detail;
 		XConfigureWindow(display, ev->window, ev->value_mask, &wc);
 	} else {
-		/*
-		fprintf(stderr, "configurerequest: change window: %lu\n",
-		    ev->window);
-		*/
 		DNPRINTF(SWM_D_EVENT, "configurerequest: change window: %lu\n",
 		    ev->window);
 		if (win->floating) {
@@ -2136,19 +2965,19 @@ configurerequest(XEvent *e)
 			if (win->ws->r != NULL) {
 				/* this seems to be full screen */
 				if (win->g.w >= WIDTH(win->ws->r)) {
-					win->g.x = -1;
+					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 = -1;
+					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)))
+			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);
@@ -2160,8 +2989,21 @@ configurerequest(XEvent *e)
 void
 configurenotify(XEvent *e)
 {
+	struct ws_win		*win;
+	long			mask;
+
 	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();
+	}
 }
 
 void
@@ -2169,29 +3011,11 @@ destroynotify(XEvent *e)
 {
 	struct ws_win		*win;
 	XDestroyWindowEvent	*ev = &e->xdestroywindow;
-	struct workspace	*ws;
 
 	DNPRINTF(SWM_D_EVENT, "destroynotify: window %lu\n", ev->window);
 
 	if ((win = find_window(ev->window)) != NULL) {
-		ws = win->ws;
-		/* find a window to focus */
-		if (ws->focus == win)
-			ws->focus = TAILQ_PREV(win, ws_win_list, entry);
-		if (ws->focus == NULL)
-			ws->focus = TAILQ_FIRST(&ws->winlist);
-		if (ws->focus == NULL || ws->focus == win) {
-			ws->focus = NULL;
-			unfocus_all();
-		} else
-			focus_win(ws->focus);
-		TAILQ_REMOVE(&ws->winlist, win, entry);
-		set_win_state(win, WithdrawnState);
-		if (win->ch.res_class)
-			XFree(win->ch.res_class);
-		if (win->ch.res_name)
-			XFree(win->ch.res_name);
-		free(win);
+		unmanage_window(win);
 		stack();
 	}
 }
@@ -2221,6 +3045,29 @@ focusin(XEvent *e)
 }
 
 void
+focusout(XEvent *e)
+{
+	DNPRINTF(SWM_D_EVENT, "focusout: window: %lu\n", e->xfocus.window);
+
+	if (cur_focus && cur_focus->ws->r &&
+	    cur_focus->id == e->xfocus.window) {
+		struct swm_screen	*s = cur_focus->ws->r->s;
+		Window			rr, cr;
+		int			x, y, wx, wy;
+		unsigned int		mask;
+
+		/* Try to detect synergy hiding the cursor.  */
+		if (XQueryPointer(display, cur_focus->id, 
+		    &rr, &cr, &x, &y, &wx, &wy, &mask) != False &&
+		    cr == 0 && !mask &&
+		    x == DisplayWidth(display, s->idx)/2 &&
+		    y == DisplayHeight(display, s->idx)/2) {
+			unfocus_win(cur_focus);
+		}
+	}
+}
+
+void
 mappingnotify(XEvent *e)
 {
 	XMappingEvent		*ev = &e->xmapping;
@@ -2246,6 +3093,7 @@ maprequest(XEvent *e)
 	if (wa.override_redirect)
 		return;
 	manage_window(e->xmaprequest.window);
+
 	stack();
 }
 
@@ -2287,7 +3135,14 @@ propertynotify(XEvent *e)
 void
 unmapnotify(XEvent *e)
 {
+	XDestroyWindowEvent	*ev = &e->xdestroywindow;
+	struct ws_win		*win;
+
 	DNPRINTF(SWM_D_EVENT, "unmapnotify: window: %lu\n", e->xunmap.window);
+
+	if ((win = find_window(ev->window)) != NULL)
+		if (win->transient)
+			unmanage_window(win);
 }
 
 void
@@ -2346,28 +3201,74 @@ getstate(Window w)
 	unsigned long		n, extra;
 	Atom			real;
 
-	astate = XInternAtom(display, "WM_STATE", False);
 	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 = *p;
+		result = *((long *)p);
 	XFree(p);
 	return (result);
 }
 
 void
-new_region(struct swm_screen *s, struct workspace *ws,
-    int x, int y, int w, int h)
+new_region(struct swm_screen *s, int x, int y, int w, int h)
 {
-	struct swm_region	*r;
+	struct swm_region	*r, *n;
+	struct workspace	*ws = NULL;
+	int			i;
 
-	DNPRINTF(SWM_D_MISC, "new region on screen %d: %dx%d (%d, %d)\n",
-	     s->idx, x, y, w, h);
+	DNPRINTF(SWM_D_MISC, "new region: screen[%d]:%dx%d+%d+%d\n",
+	     s->idx, w, h, x, y);
+
+	/* remove any conflicting regions */
+	n = TAILQ_FIRST(&s->rl);
+	while (n) {
+		r = n;
+		n = TAILQ_NEXT(r, entry);
+		if (X(r) < (x + w) &&
+		    (X(r) + WIDTH(r)) > x &&
+		    Y(r) < (y + h) &&
+		    (Y(r) + HEIGHT(r)) > y) {
+			XDestroyWindow(display, r->bar_window);
+			TAILQ_REMOVE(&s->rl, r, entry);
+			TAILQ_INSERT_TAIL(&s->orl, r, entry);
+		}
+	}
 
-	if ((r = calloc(1, sizeof(struct swm_region))) == NULL)
-		errx(1, "calloc: failed to allocate memory for screen");
+	/* search old regions for one to reuse */
+
+	/* size + location match */
+	TAILQ_FOREACH(r, &s->orl, entry)
+		if (X(r) == x && Y(r) == y &&
+		    HEIGHT(r) == h && WIDTH(r) == w)
+			break;
+
+	/* size match */
+	TAILQ_FOREACH(r, &s->orl, entry)
+		if (HEIGHT(r) == h && WIDTH(r) == w)
+			break;
+
+	if (r != NULL) {
+		TAILQ_REMOVE(&s->orl, r, entry);
+		/* try to use old region's workspace */
+		if (r->ws->r == NULL)
+			ws = r->ws;
+	} else
+		if ((r = calloc(1, sizeof(struct swm_region))) == NULL)
+			errx(1, "calloc: failed to allocate memory for screen");
+
+	/* if we don't have a workspace already, find one */
+	if (ws == NULL) {
+		for (i = 0; i < SWM_WS_MAX; i++)
+			if (s->ws[i].r == NULL) {
+				ws = &s->ws[i];
+				break;
+			}
+	}
+
+	if (ws == NULL)
+		errx(1, "no free workspaces\n");
 
 	X(r) = x;
 	Y(r) = y;
@@ -2377,24 +3278,108 @@ new_region(struct swm_screen *s, struct workspace *ws,
 	r->ws = ws;
 	ws->r = r;
 	TAILQ_INSERT_TAIL(&s->rl, r, entry);
-	bar_setup(r);
 }
 
 void
-setup_screens(void)
+scan_xrandr(int i)
 {
 #ifdef SWM_XRR_HAS_CRTC
 	XRRCrtcInfo		*ci;
 	XRRScreenResources	*sr;
 	int			c;
+	int			ncrtc = 0;
 #endif /* SWM_XRR_HAS_CRTC */
+	struct swm_region	*r;
+
+
+	if (i >= ScreenCount(display))
+		errx(1, "invalid screen");
+
+	/* remove any old regions */
+	while ((r = TAILQ_FIRST(&screens[i].rl)) != NULL) {
+		r->ws->r = NULL;
+		XDestroyWindow(display, r->bar_window);
+		TAILQ_REMOVE(&screens[i].rl, r, entry);
+		TAILQ_INSERT_TAIL(&screens[i].orl, r, entry);
+	}
+
+	/* map virtual screens onto physical screens */
+#ifdef SWM_XRR_HAS_CRTC
+	if (xrandr_support) {
+		sr = XRRGetScreenResources(display, screens[i].root);
+		if (sr == NULL)
+			new_region(&screens[i], 0, 0,
+			    DisplayWidth(display, i),
+			    DisplayHeight(display, i)); 
+		else 
+			ncrtc = sr->ncrtc;
+
+		for (c = 0, ci = NULL; c < ncrtc; c++) {
+			ci = XRRGetCrtcInfo(display, sr, sr->crtcs[c]);
+			if (ci->noutput == 0)
+				continue;
+
+			if (ci != NULL && ci->mode == None)
+				new_region(&screens[i], 0, 0,
+				    DisplayWidth(display, i),
+				    DisplayHeight(display, i)); 
+			else
+				new_region(&screens[i],
+				    ci->x, ci->y, ci->width, ci->height);
+		}
+		if (ci)
+			XRRFreeCrtcInfo(ci);
+		XRRFreeScreenResources(sr);
+	} else
+#endif /* SWM_XRR_HAS_CRTC */
+	{
+		new_region(&screens[i], 0, 0, DisplayWidth(display, i),
+		    DisplayHeight(display, i)); 
+	}
+}
+
+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);
+
+	if (!XRRUpdateConfiguration(e))
+		return;
+
+	/* silly event doesn't include the screen index */
+	for (i = 0; i < ScreenCount(display); i++)
+		if (screens[i].root == xe->root)
+			break;
+	if (i >= ScreenCount(display))
+		errx(1, "screenchange: screen not found\n");
+
+	/* 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)
+			bar_setup(r);
+	stack();
+}
+
+void
+setup_screens(void)
+{
 	Window			d1, d2, *wins = NULL;
 	XWindowAttributes	wa;
-	struct swm_region	*r;
 	unsigned int		no;
-	int			errorbase, major, minor;
-	int			ncrtc = 0, w = 0;
         int			i, j, k;
+	int			errorbase, major, minor;
 	struct workspace	*ws;
 	int			ws_idx_atom;
 
@@ -2404,13 +3389,20 @@ setup_screens(void)
 		errx(1, "calloc: screens");
 
 	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
-	
+
+	/* initial Xrandr setup */
+	xrandr_support = XRRQueryExtension(display,
+	    &xrandr_eventbase, &errorbase);
+	if (xrandr_support)
+		if (XRRQueryVersion(display, &major, &minor) && major < 1)
+       	               	xrandr_support = 0;
 
 	/* map physical screens */
 	for (i = 0; i < ScreenCount(display); i++) {
 		DNPRINTF(SWM_D_WS, "setup_screens: init screen %d\n", i);
 		screens[i].idx = i;
 		TAILQ_INIT(&screens[i].rl);
+		TAILQ_INIT(&screens[i].orl);
 		screens[i].root = RootWindow(display, i);
 
 		/* set default colors */
@@ -2421,6 +3413,7 @@ setup_screens(void)
 		setscreencolor("rgb:a0/a0/a0", i + 1, SWM_S_COLOR_BAR_FONT);
 
 		/* 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;
@@ -2435,83 +3428,38 @@ setup_screens(void)
 					    SWM_ARG_ID_STACKINIT);
 			ws->cur_layout = &layouts[0];
 		}
-
-		/* map virtual screens onto physical screens */
-		screens[i].xrandr_support = XRRQueryExtension(display,
-		    &xrandr_eventbase, &errorbase);
-		if (screens[i].xrandr_support)
-			if (XRRQueryVersion(display, &major, &minor) &&
-			    major < 1)
-                        	screens[i].xrandr_support = 0;
-
-#if 0	/* not ready for dynamic screen changes */
-		if (screens[i].xrandr_support)
-			XRRSelectInput(display,
-			    screens[r->s].root,
-			    RRScreenChangeNotifyMask);
-#endif
-
 		/* grab existing windows (before we build the bars)*/
 		if (!XQueryTree(display, screens[i].root, &d1, &d2, &wins, &no))
 			continue;
 
-#ifdef SWM_XRR_HAS_CRTC
-		sr = XRRGetScreenResources(display, screens[i].root);
-		if (sr == NULL)
-			new_region(&screens[i], &screens[i].ws[w],
-			    0, 0, DisplayWidth(display, i),
-			    DisplayHeight(display, i)); 
-		else 
-			ncrtc = sr->ncrtc;
-
-		for (c = 0, ci = NULL; c < ncrtc; c++) {
-			ci = XRRGetCrtcInfo(display, sr, sr->crtcs[c]);
-			if (ci->noutput == 0)
-				continue;
+		scan_xrandr(i);
 
-			if (ci != NULL && ci->mode == None)
-				new_region(&screens[i], &screens[i].ws[w], 0, 0,
-				    DisplayWidth(display, i),
-				    DisplayHeight(display, i)); 
-			else
-				new_region(&screens[i], &screens[i].ws[w],
-				    ci->x, ci->y, ci->width, ci->height);
-			w++;
-		}
-		if (ci)
-			XRRFreeCrtcInfo(ci);
-		XRRFreeScreenResources(sr);
-#else
-		new_region(&screens[i], &screens[i].ws[w], 0, 0,
-		    DisplayWidth(display, i),
-		    DisplayHeight(display, i)); 
-#endif /* SWM_XRR_HAS_CRTC */
+		if (xrandr_support)
+			XRRSelectInput(display, screens[i].root,
+			    RRScreenChangeNotifyMask);
 
 		/* attach windows to a region */
 		/* normal windows */
-		if ((r = TAILQ_FIRST(&screens[i].rl)) == NULL)
-			errx(1, "no regions on screen %d", i);
-
-		for (i = 0; i < no; i++) {
-                        XGetWindowAttributes(display, wins[i], &wa);
-			if (!XGetWindowAttributes(display, wins[i], &wa) ||
+		for (j = 0; j < no; j++) {
+                        XGetWindowAttributes(display, wins[j], &wa);
+			if (!XGetWindowAttributes(display, wins[j], &wa) ||
 			    wa.override_redirect ||
-			    XGetTransientForHint(display, wins[i], &d1))
+			    XGetTransientForHint(display, wins[j], &d1))
 				continue;
 
 			if (wa.map_state == IsViewable ||
-			    getstate(wins[i]) == NormalState)
-				manage_window(wins[i]);
+			    getstate(wins[j]) == NormalState)
+				manage_window(wins[j]);
 		}
 		/* transient windows */
-		for (i = 0; i < no; i++) {
-			if (!XGetWindowAttributes(display, wins[i], &wa))
+		for (j = 0; j < no; j++) {
+			if (!XGetWindowAttributes(display, wins[j], &wa))
 				continue;
 
-			if (XGetTransientForHint(display, wins[i], &d1) &&
-			    (wa.map_state == IsViewable || getstate(wins[i]) ==
+			if (XGetTransientForHint(display, wins[j], &d1) &&
+			    (wa.map_state == IsViewable || getstate(wins[j]) ==
 			    NormalState))
-				manage_window(wins[i]);
+				manage_window(wins[j]);
                 }
                 if (wins) {
                         XFree(wins);
@@ -2520,14 +3468,35 @@ setup_screens(void)
 	}
 }
 
+void
+workaround(void)
+{
+	int			i;
+	Atom			netwmcheck, netwmname, utf8_string;
+	Window			root;
+
+	/* work around sun jdk bugs, code from wmname */
+	netwmcheck = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", False);
+	netwmname = XInternAtom(display, "_NET_WM_NAME", False);
+	utf8_string = XInternAtom(display, "UTF8_STRING", False);
+	for (i = 0; i < ScreenCount(display); i++) {
+		root = screens[i].root;
+		XChangeProperty(display, root, netwmcheck, XA_WINDOW, 32,
+		    PropModeReplace, (unsigned char *)&root, 1);
+		XChangeProperty(display, root, netwmname, utf8_string, 8,
+		    PropModeReplace, "LG3D", strlen("LG3D"));
+	}
+}
+
 int
 main(int argc, char *argv[])
 {
 	struct passwd		*pwd;
+	struct swm_region	*r;
 	char			conf[PATH_MAX], *cfile = NULL;
 	struct stat		sb;
 	XEvent			e;
-	int			xfd;
+	int			xfd, i;
 	fd_set			rd;
 
 	start_argv = argv;
@@ -2543,6 +3512,8 @@ main(int argc, char *argv[])
 		errx(1, "other wm running");
 
 	astate = XInternAtom(display, "WM_STATE", False);
+	aprot = XInternAtom(display, "WM_PROTOCOLS", False);
+	adelete = XInternAtom(display, "WM_DELETE_WINDOW", False);
 
 	/* look for local and global conf file */
 	pwd = getpwuid(getuid());
@@ -2550,6 +3521,8 @@ main(int argc, char *argv[])
 		errx(1, "invalid user %d", getuid());
 
 	setup_screens();
+	setup_keys();
+	setup_quirks();
 
 	snprintf(conf, sizeof conf, "%s/.%s", pwd->pw_dir, SWM_CONF_FILE);
 	if (stat(conf, &sb) != -1) {
@@ -2564,9 +3537,14 @@ main(int argc, char *argv[])
 	}
 	if (cfile)
 		conf_load(cfile);
-	bar_refresh();
 
-	/* ws[0].focus = TAILQ_FIRST(&ws[0].winlist); */
+	/* setup all bars */
+	for (i = 0; i < ScreenCount(display); i++)
+		TAILQ_FOREACH(r, &screens[i].rl, entry)
+			bar_setup(r);
+
+	/* set some values to work around bad programs */
+	workaround();
 
 	grabkeys();
 	stack();
@@ -2582,10 +3560,27 @@ main(int argc, char *argv[])
 			bar_alarm = 0;
 			bar_update();
 		}
-		while(XPending(display)) {
+		while (XPending(display)) {
 			XNextEvent(display, &e);
-			if (handler[e.type])
-				handler[e.type](&e);
+			if (e.type < LASTEvent) {
+				if (handler[e.type])
+					handler[e.type](&e);
+				else
+					DNPRINTF(SWM_D_EVENT,
+					    "win: %lu unknown event: %d\n",
+					    e.xany.window, e.type);
+			} else {
+				switch (e.type - xrandr_eventbase) {
+				case RRScreenChangeNotify:
+					screenchange(&e);
+					break;
+				default:
+					DNPRINTF(SWM_D_EVENT,
+					    "win: %lu unknown xrandr event: "
+					    "%d\n", e.xany.window, e.type);
+					break;
+				}
+			}
 		}
 	}