Import of vwm2 changes from published source tgz

 Major changes from vwm1:

  - GNU screen-based "console" integration for monitored launching of X
    clients via screen remote commands, replacing the simple double fork
    approach used in vwm1.  Clients exiting with non-zero status retain
    their screen window in the console for 86400 seconds, facilitating
    easier debugging and troubleshooting.  The console xterm is accessed in
    the shelf and has a red border by default.

  - Xinerama/multihead support backported from vwm3, including the "screen
    fencing" implementation facilitating screen-oriented window focus
    cycling.

    Shifting the Mod1-Tab window cycling focuses the next most recently
    used window on another display.  Unshifted stays confined to the
    current display.

  - SYNC extension integration for prioritizing the WM over other X clients

  - setpriority() integration for "nicing" X client processes relative to
    the WM process

  - "autoconf" windows, horizontal/vertical halfscreen windows,
    quarterscreen windows in addition to the full/all screen functions.

    Mod1-[ and Mod1-] resize the focused window vertically with left and
    right justification to half the screen in width.  Shifting these does
    the same thing just horizontally.  Repeating the operation with a
    second ] or [ press quarters the window in the respective screen
    corner, extending upon the repeater pattern established in vwm1 for
    full/allscreen windows with Mod1-k[k[k]]

  - Exit now requires 3 consecutive strikes of Mod1-Esc

  - Introduction of a README file

1 files changed, 758 insertions, 293 deletions

diff --git a/vwm.c b/vwm.c
index e7a1a5e..77836b1 100644
--- a/vwm.c
+++ b/vwm.c
@@ -1,12 +1,11 @@
 /*
- *  VWM - Vito's Window Manager, a minimal, non-reparenting X11 window manager
+ *  vwm - Vito's Window Manager, a minimal, non-reparenting X11 window manager
  *
- *  Copyright (C) 2012  Vito Caputo - <vcaputo@gnugeneration.com>
+ *  Copyright (C) 2012-2014  Vito Caputo - <vcaputo@gnugeneration.com>
  *
- *  This program is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation, either version 3 of the License, or
- *  (at your option) any later version.
+ *  This program is free software: you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 3 as published
+ *  by the Free Software Foundation.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -21,41 +20,80 @@
  * clearly I decided to just use Xlib instead at some point, and here we are.
  */
 
+/* 4/25/2013 - Incorporated use of a screen session as a console/launcher.
+ * This introduces a shelved-at-startup window containing an xterm running
+ * a screen where all vwm-launched processes are executed with output
+ * captured.  Most WM's I've used don't provide a way to access the
+ * stdout/stderr of WM-launched applications.
+ *
+ * vwm now depends on GNU screen as a result.
+ */
+
+/* 6/09/2014 - After receiving a Xinerama-enabling patch from Philip Freeman,
+ * Xinerama support was added using his patch as a basis.  There are still some
+ * rough edges though as I don't generally work at a multihead desk.
+ * See XINERAMA in the TODO file.
+ */
+
+
 #include <X11/Xlib.h>
 #include <X11/keysym.h>
 #include <X11/cursorfont.h>
 #include <X11/Xatom.h>
+#include <X11/extensions/sync.h>	/* SYNC extension, enables us to give vwm the highest X client priority, helps keep vwm responsive at all times */
+#include <X11/extensions/Xinerama.h>	/* XINERAMA extension, facilitates easy multihead awareness */
+#include <X11/extensions/Xrandr.h>	/* RANDR extension, facilitates display configuration change awareness */
 #include <unistd.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
+#include <stdarg.h>
 #include <string.h>
 #include <inttypes.h>
+#include <values.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #include "vwm.h"
 
 #define WINDOW_BORDER_WIDTH			1
-#define WINDOW_CASCADE_DELTA			100
+#define CONSOLE_WM_CLASS			"VWMConsoleXTerm"		/* the class we specify to the "console" xterm */
+#define CONSOLE_SESSION_STRING			"_vwm_console.$DISPLAY"		/* the unique console screen session identifier */
+
+#define WM_GRAB_MODIFIER			Mod1Mask			/* the modifier for invoking vwm's controls */
+										/* Mod4Mask would be the windows key instead of Alt, but there's an assumption
+										 * in the code that grabs are being activated by Alt which complicates changing it,
+										 * search for XGetModifierMapping to see where, feel free to fix it.  Or you can
+										 * just hack the code to expect the appropriate key instead of Alt, I didn't see the
+										 * value of making it modifier mapping aware if it's always Alt for me. */
+#define LAUNCHED_RELATIVE_PRIORITY		10				/* the wm priority plus this is used as the priority of launched processes */
+#define HONOR_OVERRIDE_REDIRECT							/* search for HONOR_OVERRIDE_REDIRECT for understanding */
+#define QUIT_CONSOLE_ON_EXIT							/* instruct the console screen session to quit @ exit */
 
 typedef enum _vwm_context_focus_t {
-	VWM_CONTEXT_FOCUS_OTHER = 0,
-	VWM_CONTEXT_FOCUS_DESKTOP,
-	VWM_CONTEXT_FOCUS_SHELF
+	VWM_CONTEXT_FOCUS_OTHER = 0,						/* focus the other context relative to the current one */
+	VWM_CONTEXT_FOCUS_DESKTOP,						/* focus the desktop context */
+	VWM_CONTEXT_FOCUS_SHELF							/* focus the shelf context */
 } vwm_context_focus_t;
 
+typedef XineramaScreenInfo vwm_screen_t;					/* conveniently reuse the xinerama type for describing screens */
 
 static LIST_HEAD(desktops);							/* global list of all (virtual) desktops in spatial created-in order */
 static LIST_HEAD(desktops_mru);							/* global list of all (virtual) desktops in MRU order */
 static LIST_HEAD(windows);							/* global list of all managed windows kept in MRU order */
+static vwm_window_t		*console = NULL;				/* the console window */
 static vwm_desktop_t		*focused_desktop = NULL;			/* currently focused (virtual) desktop */
 static vwm_window_t		*focused_shelf = NULL;				/* currently focused shelved window */
 static vwm_context_focus_t	focused_context = VWM_CONTEXT_FOCUS_DESKTOP;	/* currently focused context */ 
 static int			key_is_grabbed = 0;				/* flag for tracking keyboard grab state */
+static int			priority;					/* scheduling priority of the vwm process, launcher nices relative to this */
+static unsigned long		fence_mask = 0;					/* global mask state for vwm_win_focus_next(... VWM_FENCE_MASKED_VIOLATE),
+										 * if you use vwm on enough screens to overflow this, pics or it didn't happen. */
 
 static Display			*display;
 static Colormap			cmap;
@@ -69,54 +107,181 @@ static int			screen_num;
 static GC			gc;
 static Atom			wm_delete_atom;
 static Atom			wm_protocols_atom;
-
+static int			sync_event, sync_error;
+static int			xinerama_event, xinerama_error;
+static int			randr_event, randr_error;
+static XineramaScreenInfo	*xinerama_screens = NULL;
+static int			xinerama_screens_cnt;
+
+static void vwm_win_unmap(vwm_window_t *vwin);
+static void vwm_win_map(vwm_window_t *vwin);
 static void vwm_win_focus(vwm_window_t *vwin);
 static void vwm_keypressed(Window win, XEvent *keypress);
 
-/* animated vwm logo done with simple XOR'd lines, a display of the WM being started and ready */
-typedef struct _vwm_point_t {
-	float	x, y;
-} vwm_point_t;
-
-vwm_point_t	vwm_logo[] = {	{0.0, 0.0},
-				{0.170731, 1.0},
-				{0.341463, 0.0},
-				{0.463414, 1.0},
-				{0.536585, 0.6},
-				{0.609756, 1.0},
-				{0.731707, 0.0},
-				{0.804878, 0.4},
-				{0.878048, 0.0},
-				{1.0, 1.0} };
+#define MIN(_a, _b) ((_a) < (_b) ? (_a) : (_b))
+#define MAX(_a, _b) ((_a) > (_b) ? (_a) : (_b))
+
+
+/* helper for returning what fraction (0.0-1.0) of vwin overlaps with scr */
+static float vwm_screen_overlaps_win(const vwm_screen_t *scr, vwm_window_t *vwin)
+{
+	float	pct = 0, xover = 0, yover = 0;
+
+	if(scr->x_org + scr->width < vwin->config.x || scr->x_org > vwin->config.x + vwin->config.width ||
+	   scr->y_org + scr->height < vwin->config.y || scr->y_org > vwin->config.y + vwin->config.height)
+	   	goto _out;
+
+	/* they overlap, by how much? */
+	xover = MIN(scr->x_org + scr->width, vwin->config.x + vwin->config.width) - MAX(scr->x_org, vwin->config.x);
+	yover = MIN(scr->y_org + scr->height, vwin->config.y + vwin->config.height) - MAX(scr->y_org, vwin->config.y);
+
+	pct = (xover * yover) / (vwin->config.width * vwin->config.height);
+_out:
+	VWM_TRACE("xover=%f yover=%f width=%i height=%i pct=%.4f", xover, yover, vwin->config.width, vwin->config.height, pct);
+	return pct;
+}
+
+
+/* helper for returning the correct screen, don't use the return value across event loops. */
+typedef enum _vwm_screen_rel_t {
+	VWM_SCREEN_REL_WINDOW,	/* return the screen the supplied window most resides in */
+	VWM_SCREEN_REL_POINTER,	/* return the screen the pointer resides in */
+	VWM_SCREEN_REL_TOTAL,	/* return the bounding rectangle of all screens as one */
+} vwm_screen_rel_t;
+
+static const vwm_screen_t * vwm_screen_find(vwm_screen_rel_t rel, ...)
+{
+	static vwm_screen_t	faux;
+	vwm_screen_t		*scr, *best = &faux; /* default to faux as best */
+	int			i;
+
+	faux.screen_number = 0;
+	faux.x_org = 0;
+	faux.y_org = 0;
+	faux.width = WidthOfScreen(DefaultScreenOfDisplay(display));
+	faux.height = HeightOfScreen(DefaultScreenOfDisplay(display));
+
+	if(!xinerama_screens) goto _out;
+
+#define for_each_screen(_tmp) \
+	for(i = 0, _tmp = xinerama_screens; i < xinerama_screens_cnt; _tmp = &xinerama_screens[++i])
+
+	switch(rel) {
+		case VWM_SCREEN_REL_WINDOW: {
+			va_list		ap;
+			vwm_window_t	*vwin;
+			float		best_pct = 0, this_pct;
+
+			va_start(ap, rel);
+			vwin = va_arg(ap, vwm_window_t *);
+			va_end(ap);
+
+			for_each_screen(scr) {
+				this_pct = vwm_screen_overlaps_win(scr, vwin);
+				if(this_pct > best_pct) {
+					best = scr;
+					best_pct = this_pct;
+				}
+			}
+			break;
+		}
+
+		case VWM_SCREEN_REL_POINTER: {
+			int		root_x, root_y, win_x, win_y;
+			unsigned int	mask;
+			Window		root, child;
+
+			/* get the pointer coordinates and find which screen it's in */
+			XQueryPointer(display, RootWindow(display, screen_num), &root, &child, &root_x, &root_y, &win_x, &win_y, &mask);
+
+			for_each_screen(scr) {
+				if(root_x >= scr->x_org && root_x < scr->x_org + scr->width &&
+				   root_y >= scr->y_org && root_y < scr->y_org + scr->height) {
+					best = scr;
+					break;
+				}
+			}
+			break;
+		}
+
+		case VWM_SCREEN_REL_TOTAL: {
+			short	x1 = MAXSHORT, y1 = MAXSHORT, x2 = MINSHORT, y2 = MINSHORT;
+			/* find the smallest x_org and y_org, the highest x_org + width and y_org + height, those are the two corners of the total rect */
+			for_each_screen(scr) {
+				if(scr->x_org < x1) x1 = scr->x_org;
+				if(scr->y_org < y1) y1 = scr->y_org;
+				if(scr->x_org + scr->width > x2) x2 = scr->x_org + scr->width;
+				if(scr->y_org + scr->height > y2) y2 = scr->y_org + scr->height;
+			}
+			faux.x_org = x1;
+			faux.y_org = y1;
+			faux.width = x2 - x1;
+			faux.height = y2 - y1;
+			best = &faux;
+			break;
+		}
+	}
+_out:
+	VWM_TRACE("Found Screen #%i: %hix%hi @ %hi,%hi", best->screen_number, best->width, best->height, best->x_org, best->y_org);
 
+	return best;
+}
+
+
+/* helper for determining if a screen contains any windows (assuming the current desktop) */
+static int vwm_screen_is_empty(const vwm_screen_t *scr)
+{
+	vwm_window_t	*vwin;
+	int		is_empty = 1;
+
+	list_for_each_entry(vwin, &windows, windows) {
+		if(vwin->desktop == focused_desktop && !vwin->shelved && !vwin->configuring) {
+			/* XXX: it may make more sense to see what %age of the screen is overlapped by windows, and consider it empty if < some % */
+			/*      This is just seeing if any window is predominantly within the specified screen, the rationale being if you had a focusable
+			 *      window on the screen you would have used the keyboard to make windows go there; this function is only used in determining
+			 *      wether a new window should go where the pointer is or not. */
+			if(vwm_screen_overlaps_win(scr, vwin) >= 0.05) {
+				is_empty = 0;
+				break;
+			}
+		}
+	}
+
+	return is_empty;
+}
+
+
+/* animated \/\/\ logo done with simple XOR'd lines, a display of the WM being started and ready */
+#define VWM_LOGO_POINTS 6
 static void vwm_draw_logo(void)
 {
-	Window		root;
-	int		x, y, i;
-	unsigned int	width, height, border_width, depth, yoff, xoff;
-	XPoint		points[sizeof(vwm_logo) / sizeof(vwm_point_t)];
+	int			i;
+	unsigned int		width, height, yoff, xoff;
+	XPoint			points[VWM_LOGO_POINTS];
+	const vwm_screen_t	*scr = vwm_screen_find(VWM_SCREEN_REL_POINTER);
 
 	XGrabServer(display);
 
-	/* learn the dimensions of the root window */
-	XGetGeometry(display, RootWindow(display, screen_num), &root, &x, &y, &width, &height, &border_width, &depth);
-
-	yoff = ((float)height * .375);
-	xoff = 0;
-	height /= 4;
+	/* use the dimensions of the pointer-containing screen */
+	width = scr->width;
+	height = scr->height;
+	xoff = scr->x_org;
+	yoff = scr->y_org + ((float)height * .333);
+	height /= 3;
 
 	/* the logo gets shrunken vertically until it's essentially a flat line */
-	while(height--) {
+	while(height -= 2) {
 		/* scale and center the points to the screen size */
-		for(i = 0; i < sizeof(points) / sizeof(XPoint); i++) {
-			points[i].x = xoff + (vwm_logo[i].x * (float)width);
-			points[i].y = (vwm_logo[i].y * (float)height) + yoff;
+		for(i = 0; i < VWM_LOGO_POINTS; i++) {
+			points[i].x = xoff + (i * .2 * (float)width);
+			points[i].y = (i % 2 * (float)height) + yoff;
 		}
 
 		XDrawLines(display, RootWindow(display, screen_num), gc, points, sizeof(points) / sizeof(XPoint), CoordModeOrigin);
 		XFlush(display);
 		usleep(3333);
 		XDrawLines(display, RootWindow(display, screen_num), gc, points, sizeof(points) / sizeof(XPoint), CoordModeOrigin);
+		XFlush(display);
 
 		/* the width is shrunken as well, but only by as much as it is tall */
 		yoff++;
@@ -129,16 +294,22 @@ static void vwm_draw_logo(void)
 
 
 /* XXX: for now just double forks to avoid having to collect return statuses of the long-running process */
-static void vwm_launch(char **argv)
+typedef enum _vwm_launch_mode_t {
+	VWM_LAUNCH_MODE_FG,
+	VWM_LAUNCH_MODE_BG,
+} vwm_launch_mode_t;
+
+static void vwm_launch(char **argv, vwm_launch_mode_t mode)
 {
-	if(!fork()) {
+	if(mode == VWM_LAUNCH_MODE_FG || !fork()) {
 		if(!fork()) {
 			/* child */
+			setpriority(PRIO_PROCESS, getpid(), priority + LAUNCHED_RELATIVE_PRIORITY);
 			execvp(argv[0], argv);
 		}
-		exit(0);
+		if(mode == VWM_LAUNCH_MODE_BG) exit(0);
 	}
-	wait(NULL);
+	wait(NULL); /* TODO: could wait for the specific pid, particularly in FG mode ... */
 }
 
 
@@ -156,14 +327,14 @@ static int vwm_context_focus(vwm_context_focus_t desired_context)
 			/* desired == DESKTOP && focused == SHELF */
 
 			VWM_TRACE("unmapping shelf window \"%s\"", focused_shelf->name);
-			XUnmapWindow(display, focused_shelf->window);
+			vwm_win_unmap(focused_shelf);
 			XFlush(display); /* for a more responsive feel */
 
 			/* map the focused desktop */
 			list_for_each_entry(vwin, &windows, windows) {
 				if(vwin->desktop == focused_desktop && !vwin->shelved) {
 					VWM_TRACE("Mapping desktop window \"%s\"", vwin->name);
-					XMapWindow(display, vwin->window);
+					vwm_win_map(vwin);
 				}
 			}
 
@@ -187,14 +358,14 @@ static int vwm_context_focus(vwm_context_focus_t desired_context)
 				list_for_each_entry(vwin, &windows, windows) {
 					if(vwin->desktop == focused_desktop) {
 						VWM_TRACE("Unmapping desktop window \"%s\"", vwin->name);
-						XUnmapWindow(display, vwin->window);
+						vwm_win_unmap(vwin);
 					}
 				}
 
 				XFlush(display); /* for a more responsive feel */
 
 				VWM_TRACE("Mapping shelf window \"%s\"", focused_shelf->name);
-				XMapWindow(display, focused_shelf->window);
+				vwm_win_map(focused_shelf);
 				vwm_win_focus(focused_shelf);
 
 				focused_context = VWM_CONTEXT_FOCUS_SHELF;
@@ -214,6 +385,7 @@ static int vwm_context_focus(vwm_context_focus_t desired_context)
 /* make the specified desktop the most recently used one */
 static void vwm_desktop_mru(vwm_desktop_t *d)
 {
+	VWM_TRACE("MRU desktop: %p", d);
 	list_move(&d->desktops_mru, &desktops_mru);
 }
 
@@ -226,28 +398,20 @@ static int vwm_desktop_focus(vwm_desktop_t *d)
 	XSync(display, False);
 
 	/* if the context switched and the focused desktop is the desired desktop there's nothing else to do */
-	if( (vwm_context_focus(VWM_CONTEXT_FOCUS_DESKTOP) && focused_desktop != d) || focused_desktop != d) {
+	if((vwm_context_focus(VWM_CONTEXT_FOCUS_DESKTOP) && focused_desktop != d) || focused_desktop != d) {
 		vwm_window_t	*w;
 
 		/* unmap the windows on the currently focused desktop, map those on the newly focused one */
 		list_for_each_entry(w, &windows, windows) {
 			if(w->shelved) continue;
-
-			if(w->desktop == focused_desktop) {
-				VWM_TRACE("Unmapping \"%s\"", w->name);
-				XUnmapWindow(display, w->window);
-			}
+			if(w->desktop == focused_desktop) vwm_win_unmap(w);
 		}
 
 		XFlush(display);
 
 		list_for_each_entry(w, &windows, windows) {
 			if(w->shelved) continue;
-
-			if(w->desktop == d) {
-				VWM_TRACE("Mapping \"%s\"", w->name);
-				XMapWindow(display, w->window);
-			}
+			if(w->desktop == d) vwm_win_map(w);
 		}
 
 		focused_desktop = d;
@@ -297,13 +461,15 @@ static void vwm_desktop_destroy(vwm_desktop_t *d)
 	/* also silently refuse to destroy the last desktop (for now) */
 	if(d->focused_window || (d->desktops.next == d->desktops.prev)) return;
 
-	/* focus another desktop if we're the focused desktop */
+	/* focus the MRU desktop that isn't this one if we're the focused desktop */
 	if(d == focused_desktop) {
-		/* we just look for one that is different from ours, relative to ours, looking at the next one then the previous */
-		if(d->desktops.next != &desktops) {
-			vwm_desktop_focus(list_entry(d->desktops.next, vwm_desktop_t, desktops));
-		} else if(d->desktops.prev != &desktops) {
-			vwm_desktop_focus(list_entry(d->desktops.prev, vwm_desktop_t, desktops));
+		vwm_desktop_t	*next_desktop;
+
+		list_for_each_entry(next_desktop, &desktops_mru, desktops_mru) {
+			if(next_desktop != d) {
+				vwm_desktop_focus(next_desktop);
+				break;
+			}
 		}
 	}
 
@@ -312,6 +478,23 @@ static void vwm_desktop_destroy(vwm_desktop_t *d)
 }
 
 
+/* unmap the specified window and set the unmapping-in-progress flag so we can discard vwm-generated UnmapNotify events */
+static void vwm_win_unmap(vwm_window_t *vwin)
+{
+	VWM_TRACE("Unmapping \"%s\"", vwin->name);
+	vwin->unmapping = 1;
+	XUnmapWindow(display, vwin->window);
+}
+
+
+/* map the specified window */
+static void vwm_win_map(vwm_window_t *vwin)
+{
+	VWM_TRACE("Mapping \"%s\"", vwin->name);
+	XMapWindow(display, vwin->window);
+}
+
+
 /* make the specified window the most recently used one */
 static void vwm_win_mru(vwm_window_t *vwin)
 {
@@ -374,50 +557,135 @@ static vwm_window_t * vwm_win_focused(void)
 	return vwin;
 }
 
-/* fullscreen a window with borders obscured "allscreen" */
-static void vwm_win_allscreen(vwm_window_t *vwin)
+
+/* "autoconfigure" windows (configuration shortcuts like fullscreen/halfscreen/quarterscreen) and restoring the window */
+typedef enum _vwm_win_autoconf_t {
+	VWM_WIN_AUTOCONF_NONE,		/* un-autoconfigured window (used to restore the configuration) */
+	VWM_WIN_AUTOCONF_QUARTER,	/* quarter-screened */
+	VWM_WIN_AUTOCONF_HALF,		/* half-screened */
+	VWM_WIN_AUTOCONF_FULL,		/* full-screened */
+	VWM_WIN_AUTOCONF_ALL		/* all-screened (borderless) */
+} vwm_win_autoconf_t;
+
+typedef enum _vwm_side_t {
+	VWM_SIDE_TOP,
+	VWM_SIDE_BOTTOM,
+	VWM_SIDE_LEFT,
+	VWM_SIDE_RIGHT
+} vwm_side_t;
+
+typedef enum _vwm_corner_t {
+	VWM_CORNER_TOP_LEFT,
+	VWM_CORNER_TOP_RIGHT,
+	VWM_CORNER_BOTTOM_RIGHT,
+	VWM_CORNER_BOTTOM_LEFT
+} vwm_corner_t;
+
+static void vwm_win_autoconf(vwm_window_t *vwin, vwm_screen_rel_t rel, vwm_win_autoconf_t conf, ...)
 {
-	Window		root;
-	int		x, y;
-	unsigned int	width, height, border_width, depth;
+	const vwm_screen_t	*scr;
+	va_list			ap;
+	XWindowChanges		changes = { .border_width = WINDOW_BORDER_WIDTH };
+
+	/* remember the current configuration as the "client" configuration if it's not an autoconfigured one. */
+	if(vwin->autoconfigured == VWM_WIN_AUTOCONF_NONE) vwin->client = vwin->config;
+
+	scr = vwm_screen_find(rel, vwin);
+	va_start(ap, conf);
+	switch(conf) {
+		case VWM_WIN_AUTOCONF_QUARTER: {
+			vwm_corner_t corner = va_arg(ap, vwm_corner_t);
+			changes.width = scr->width / 2 - (WINDOW_BORDER_WIDTH * 2);
+			changes.height = scr->height / 2 - (WINDOW_BORDER_WIDTH * 2);
+			switch(corner) {
+				case VWM_CORNER_TOP_LEFT:
+					changes.x = scr->x_org;
+					changes.y = scr->y_org;
+					break;
 
-	if(vwin->fullscreened == 2) return;
+				case VWM_CORNER_TOP_RIGHT:
+					changes.x = scr->x_org + scr->width / 2;
+					changes.y = scr->y_org;
+					break;
 
-	XGetGeometry(display, RootWindow(display, screen_num), &root, &x, &y, &width, &height, &border_width, &depth);
-	XGetGeometry(display, vwin->window, &root, &vwin->client.x, &vwin->client.y, &vwin->client.width, &vwin->client.height, &border_width, &depth);
-	XMoveResizeWindow(display, vwin->window, -border_width, -border_width, width, height);
-	vwin->fullscreened = 2;
-}
+				case VWM_CORNER_BOTTOM_RIGHT:
+					changes.x = scr->x_org + scr->width / 2;
+					changes.y = scr->y_org + scr->height / 2;
+					break;
 
-/* fullscreen a window */
-static void vwm_win_fullscreen(vwm_window_t *vwin)
-{
-	Window		root;
-	int		x, y;
-	unsigned int	width, height, border_width, depth;
+				case VWM_CORNER_BOTTOM_LEFT:
+					changes.x = scr->x_org;
+					changes.y = scr->y_org + scr->height / 2;
+					break;
+			}
+			break;
+		}
 
-	if(vwin->fullscreened == 1) return;
+		case VWM_WIN_AUTOCONF_HALF: {
+			vwm_side_t side = va_arg(ap, vwm_side_t);
+			switch(side) {
+				case VWM_SIDE_TOP:
+					changes.width = scr->width - (WINDOW_BORDER_WIDTH * 2);
+					changes.height = scr->height / 2 - (WINDOW_BORDER_WIDTH * 2);
+					changes.x = scr->x_org;
+					changes.y = scr->y_org;
+					break;
 
-	XGetGeometry(display, RootWindow(display, screen_num), &root, &x, &y, &width, &height, &border_width, &depth);
-	/* TODO: do not remember the current geometry if we're going from allscreen to fullscreen! */
-	XGetGeometry(display, vwin->window, &root, &vwin->client.x, &vwin->client.y, &vwin->client.width, &vwin->client.height, &border_width, &depth);
-	XMoveResizeWindow(display, vwin->window, 0, 0, width - (border_width * 2), height - (border_width * 2));
-	vwin->fullscreened = 1;
-}
+				case VWM_SIDE_BOTTOM:
+					changes.width = scr->width - (WINDOW_BORDER_WIDTH * 2);
+					changes.height = scr->height / 2 - (WINDOW_BORDER_WIDTH * 2);
+					changes.x = scr->x_org;
+					changes.y = scr->y_org + scr->height / 2;
+					break;
 
+				case VWM_SIDE_LEFT:
+					changes.width = scr->width / 2 - (WINDOW_BORDER_WIDTH * 2);
+					changes.height = scr->height - (WINDOW_BORDER_WIDTH * 2);
+					changes.x = scr->x_org;
+					changes.y = scr->y_org;
+					break;
 
-/* restore a window to its non-fullscreened size and coordinates */
-static void vwm_win_restore(vwm_window_t *vwin)
-{
-	if(!vwin->fullscreened) return;
+				case VWM_SIDE_RIGHT:
+					changes.width = scr->width / 2 - (WINDOW_BORDER_WIDTH * 2);
+					changes.height = scr->height - (WINDOW_BORDER_WIDTH * 2);
+					changes.x = scr->x_org + scr->width / 2;
+					changes.y = scr->y_org;
+					break;
+			}
+			break;
+		}
 
-	XMoveResizeWindow(display, vwin->window, vwin->client.x, vwin->client.y, vwin->client.width, vwin->client.height);
-	vwin->fullscreened = 0;
+		case VWM_WIN_AUTOCONF_FULL:
+			changes.width = scr->width - WINDOW_BORDER_WIDTH * 2;
+			changes.height = scr->height - WINDOW_BORDER_WIDTH * 2;
+			changes.x = scr->x_org;
+			changes.y = scr->y_org;
+			break;
+
+		case VWM_WIN_AUTOCONF_ALL:
+			changes.width = scr->width;
+			changes.height = scr->height;
+			changes.x = scr->x_org;
+			changes.y = scr->y_org;
+			changes.border_width = 0;
+			break;
+
+		case VWM_WIN_AUTOCONF_NONE: /* restore window if autoconfigured */
+			changes.width = vwin->client.width;
+			changes.height = vwin->client.height;
+			changes.x = vwin->client.x;
+			changes.y = vwin->client.y;
+			break;
+	}
+	va_end(ap);
+
+	XConfigureWindow(display, vwin->window, CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &changes);
+	vwin->autoconfigured = conf;
 }
 
 
 /* focus a window */
-/* this updates window borders as needed and the X input focus */
+/* this updates window border color as needed and the X input focus */
 static void vwm_win_focus(vwm_window_t *vwin)
 {
 	VWM_TRACE("focusing: %#x", (unsigned int)vwin->window);
@@ -428,7 +696,9 @@ static void vwm_win_focus(vwm_window_t *vwin)
 	/* update the border color accordingly */
 	if(vwin->shelved) {
 		/* set the border of the newly focused window to the shelved color */
-		XSetWindowBorder(display, vwin->window, shelved_window_border_color.pixel);
+		XSetWindowBorder(display, vwin->window, vwin == console ? shelved_console_border_color.pixel : shelved_window_border_color.pixel);
+		/* fullscreen windows in the shelf when focused, since we don't intend to overlap there */
+		vwm_win_autoconf(vwin, VWM_SCREEN_REL_POINTER, VWM_WIN_AUTOCONF_FULL);	/* XXX TODO: for now the shelf follows the pointer, it's simple. */
 	} else {
 		if(vwin->desktop == focused_desktop && focused_desktop->focused_window) {
 			/* if we've changed focus within the same desktop, set the currently focused window border to the
@@ -445,16 +715,53 @@ static void vwm_win_focus(vwm_window_t *vwin)
 }
 
 
-/* focus the next window on a virtual desktop relative to the supplied window */
-static vwm_window_t * vwm_win_focus_next(vwm_window_t *vwin, vwm_context_focus_t context)
+/* focus the next window on a virtual desktop relative to the supplied window, in the specified context, respecting screen boundaries according to fence. */
+typedef enum _vwm_fence_t {
+	VWM_FENCE_IGNORE = 0,		/* behave as if screen boundaries don't exist (like the pre-Xinerama code) */
+	VWM_FENCE_RESPECT,		/* confine operation to within the screen */
+	VWM_FENCE_TRY_RESPECT,		/* confine operation to within the screen, unless no options exist. */
+	VWM_FENCE_VIOLATE,		/* leave the screen for any other*/
+	VWM_FENCE_MASKED_VIOLATE	/* leave the screen for any other not masked */
+} vwm_fence_t;
+
+static vwm_window_t * vwm_win_focus_next(vwm_window_t *vwin, vwm_context_focus_t context, vwm_fence_t fence)
 {
-	vwm_window_t	*next;
+	const vwm_screen_t	*scr = vwm_screen_find(VWM_SCREEN_REL_WINDOW, vwin), *next_scr = NULL;
+	vwm_window_t		*next;
+	unsigned long		visited_mask;
 
+_retry:
+	visited_mask = 0;
 	list_for_each_entry(next, &vwin->windows, windows) {
 		/* searching for the next mapped window in this context, using vwin->windows as the head */
 		if(&next->windows == &windows) continue;	/* XXX: skip the containerless head, we're leveraging the circular list implementation */
 
-		if(next->mapped && ((context == VWM_CONTEXT_FOCUS_SHELF && next->shelved) || (context == VWM_CONTEXT_FOCUS_DESKTOP && !next->shelved && next->desktop == focused_desktop))) break;
+		if((context == VWM_CONTEXT_FOCUS_SHELF && next->shelved) ||
+		   ((context == VWM_CONTEXT_FOCUS_DESKTOP && !next->shelved && next->desktop == focused_desktop) &&
+		    (fence == VWM_FENCE_IGNORE ||
+		     ((fence == VWM_FENCE_RESPECT || fence == VWM_FENCE_TRY_RESPECT) && vwm_screen_find(VWM_SCREEN_REL_WINDOW, next) == scr) ||
+		     (fence == VWM_FENCE_VIOLATE && vwm_screen_find(VWM_SCREEN_REL_WINDOW, next) != scr) ||
+		     (fence == VWM_FENCE_MASKED_VIOLATE && (next_scr = vwm_screen_find(VWM_SCREEN_REL_WINDOW, next)) != scr &&
+		      !((1UL << next_scr->screen_number) & fence_mask))
+		    ))) break;
+
+		  if(fence == VWM_FENCE_MASKED_VIOLATE && next_scr && next_scr != scr) visited_mask |= (1UL << next_scr->screen_number);
+	}
+
+	if(fence == VWM_FENCE_TRY_RESPECT && next == vwin) {
+		/* if we tried to respect the fence and failed to find a next, fallback to ignoring the fence and try again */
+		fence = VWM_FENCE_IGNORE;
+		goto _retry;
+	} else if(fence == VWM_FENCE_MASKED_VIOLATE && next_scr) {
+		/* if we did a masked violate update the mask with the potentially new screen number */
+		if(next == vwin && visited_mask) {
+			/* if we failed to find a next window on a different screen but had candidates we've exhausted screens and need to reset the mask then retry */
+			VWM_TRACE("all candidate screens masked @ 0x%lx, resetting mask", fence_mask);
+			fence_mask = 0;
+			goto _retry;
+		}
+		fence_mask |= (1UL << next_scr->screen_number);
+		VWM_TRACE("VWM_FENCE_MASKED_VIOLATE fence_mask now: 0x%lx\n", fence_mask);
 	}
 
 	switch(context) {
@@ -469,13 +776,11 @@ static vwm_window_t * vwm_win_focus_next(vwm_window_t *vwin, vwm_context_focus_t
 		case VWM_CONTEXT_FOCUS_SHELF:
 			if(next != focused_shelf) {
 				/* shelf switch, unmap the focused shelf and take it over */
-				VWM_TRACE("Unmapping window \"%s\"", focused_shelf->name);
-				XUnmapWindow(display, focused_shelf->window);
+				vwm_win_unmap(focused_shelf);
 
 				XFlush(display);
 
-				VWM_TRACE("Mapping window \"%s\"", next->name);
-				XMapWindow(display, next->window);
+				vwm_win_map(next);
 				focused_shelf = next;
 				vwm_win_focus(next);
 			}
@@ -500,7 +805,7 @@ static void vwm_win_shelve(vwm_window_t *vwin)
 
 	/* shelving focused window, focus the next window */
 	if(vwin == vwin->desktop->focused_window) {
-		vwm_win_mru(vwm_win_focus_next(vwin, VWM_CONTEXT_FOCUS_DESKTOP));
+		vwm_win_mru(vwm_win_focus_next(vwin, VWM_CONTEXT_FOCUS_DESKTOP, VWM_FENCE_RESPECT));
 	}
 
 	if(vwin == vwin->desktop->focused_window) {
@@ -514,8 +819,7 @@ static void vwm_win_shelve(vwm_window_t *vwin)
 	/* newly shelved windows always become the focused shelf */
 	focused_shelf = vwin;
 
-	VWM_TRACE("Unmapping \"%s\"", vwin->name);
-	XUnmapWindow(display, vwin->window);
+	vwm_win_unmap(vwin);
 }
 
 
@@ -524,7 +828,7 @@ typedef enum _vwm_grab_mode_t {
 	VWM_GRABBED
 } vwm_grab_mode_t;
 
-/* manages a new window (called in response to CreateNotify events, and during startup to manage existing windows) */
+/* manages a mapped window (called in response to MapRequest events, and during startup to manage existing windows) */
 static vwm_window_t * vwm_win_manage(Window win, vwm_grab_mode_t grabbed)
 {
 	XWindowAttributes	attrs;
@@ -540,17 +844,14 @@ static vwm_window_t * vwm_win_manage(Window win, vwm_grab_mode_t grabbed)
 	if(!XGetWindowAttributes(display, win, &attrs)) goto _fail_grabbed;
 
 	/* honor overrides, don't manage InputOnly windows */
+#ifdef HONOR_OVERRIDE_REDIRECT
 	if(attrs.override_redirect || attrs.class == InputOnly) goto _fail_grabbed;
+#else
+	if(attrs.class == InputOnly) goto _fail_grabbed;
+#endif
 
 	VWM_TRACE("Managing %#x", (unsigned int)win);
 
-	/* if no desktops exist, implicitly create one */
-	if(!focused_desktop) {
-		/* TODO: interactively name desktops */
-		vwm_desktop_focus(vwm_desktop_create(NULL));
-		vwm_desktop_mru(focused_desktop);
-	}
-
 	/* allocate and initialize our per-managed-window structure and get it on the global windows list */
 	vwin = (vwm_window_t *)malloc(sizeof(vwm_window_t));
 	if(vwin == NULL) {
@@ -559,8 +860,8 @@ static vwm_window_t * vwm_win_manage(Window win, vwm_grab_mode_t grabbed)
 	}
 
         XUngrabButton(display, AnyButton, AnyModifier, win);
-	XGrabButton(display, AnyButton, Mod1Mask, win, False, (PointerMotionMask | ButtonPressMask | ButtonReleaseMask), GrabModeAsync, GrabModeAsync, None, None);
-	XGrabKey(display, AnyKey, Mod1Mask, win, False, GrabModeAsync, GrabModeAsync);
+	XGrabButton(display, AnyButton, WM_GRAB_MODIFIER, win, False, (PointerMotionMask | ButtonPressMask | ButtonReleaseMask), GrabModeAsync, GrabModeAsync, None, None);
+	XGrabKey(display, AnyKey, WM_GRAB_MODIFIER, win, False, GrabModeAsync, GrabModeAsync);
 	XSetWindowBorder(display, win, unfocused_window_border_color.pixel);
 
 	vwin->name = NULL;
@@ -575,15 +876,17 @@ static vwm_window_t * vwm_win_manage(Window win, vwm_grab_mode_t grabbed)
 
 	vwin->desktop = focused_desktop;
 	vwin->window = win;
-	vwin->fullscreened = 0;
+	vwin->autoconfigured = VWM_WIN_AUTOCONF_NONE;
+	vwin->unmapping = 0;
+	vwin->configuring = 0;
 	vwin->shelved = (focused_context == VWM_CONTEXT_FOCUS_SHELF);	/* if we're in the shelf when the window is created, the window is shelved */
-	vwin->mapped = (attrs.map_state != IsUnmapped);
 
 	/* remember whatever the current attributes are */
 	vwin->client.x = attrs.x;
 	vwin->client.y = attrs.y;
 	vwin->client.width = attrs.width;
 	vwin->client.height = attrs.height;
+	vwin->config = vwin->client;
 
 	VWM_TRACE("hints: flags=%lx x=%i y=%i w=%i h=%i minw=%i minh=%i maxw=%i maxh=%i winc=%i hinc=%i basew=%i baseh=%i grav=%x",
 			vwin->hints->flags,
@@ -608,10 +911,12 @@ static vwm_window_t * vwm_win_manage(Window win, vwm_grab_mode_t grabbed)
 		list_add(&vwin->windows, &windows);
 	}
 
-	/* if the desktop has no focused window yet, automatically focus the newly managed one */
-	/* TODO: how does this interact with the shelf? */
-	if(!focused_desktop->focused_window) {
-		VWM_TRACE("Mapped window \"%s\" is alone on desktop \"%s\", focusing", vwin->name, focused_desktop->name);
+	/* always raise newly managed windows so we know about them. */
+	XRaiseWindow(display, vwin->window);
+
+	/* if the desktop has no focused window yet, automatically focus the newly managed one, provided we're on the desktop context */
+	if(!focused_desktop->focused_window && focused_context == VWM_CONTEXT_FOCUS_DESKTOP) {
+		VWM_TRACE("Mapped new window \"%s\" is alone on desktop \"%s\", focusing", vwin->name, focused_desktop->name);
 		vwm_win_focus(vwin);
 	}
 
@@ -630,10 +935,10 @@ _fail_grabbed:
 static void vwm_win_unfocus(vwm_window_t *vwin)
 {
 	/* if we're the shelved window, cycle the focus to the next shelved window if possible, if there's no more shelf, switch to the desktop */
-	/* TODO: what if it's not mapped but goes away???  we don't want to try take the InputFocus it when not mapped... XXX TODO */
+	/* TODO: there's probably some icky behaviors for focused windows unmapping/destroying in unfocused contexts, we probably jump contexts suddenly. */
 	if(vwin == focused_shelf) {
 		VWM_TRACE("unfocusing focused shelf");
-		vwm_win_focus_next(vwin, VWM_CONTEXT_FOCUS_SHELF);
+		vwm_win_focus_next(vwin, VWM_CONTEXT_FOCUS_SHELF, VWM_FENCE_IGNORE);
 
 		if(vwin == focused_shelf) {
 			VWM_TRACE("shelf empty, leaving");
@@ -646,7 +951,7 @@ static void vwm_win_unfocus(vwm_window_t *vwin)
 	/* if we're the focused window cycle the focus to the next window on the desktop if possible */
 	if(vwin->desktop->focused_window == vwin) {
 		VWM_TRACE("unfocusing focused window");
-		vwm_win_focus_next(vwin, VWM_CONTEXT_FOCUS_DESKTOP);
+		vwm_win_focus_next(vwin, VWM_CONTEXT_FOCUS_DESKTOP, VWM_FENCE_TRY_RESPECT);
 	}
 
 	if(vwin->desktop->focused_window == vwin) {
@@ -656,7 +961,7 @@ static void vwm_win_unfocus(vwm_window_t *vwin)
 }
 
 
-/* migrate a window to a new desktop, focuses the destionation desktop as well */
+/* migrate a window to a new desktop, focuses the destination desktop as well */
 static void vwm_win_migrate(vwm_window_t *vwin, vwm_desktop_t *desktop)
 {
 	/* go through the motions of unfocusing the window if it is focused */
@@ -673,7 +978,7 @@ static void vwm_win_migrate(vwm_window_t *vwin, vwm_desktop_t *desktop)
 
 	/* focus the window so borders get updated */
 	vwm_win_focus(vwin);
-	vwm_win_mru(vwin);
+	vwm_win_mru(vwin); /* TODO: is this right? shouldn't the Mod1 release be what's responsible for this? I migrate so infrequently it probably doesn't matter */
 
 	/* ensure the window is raised */
 	XRaiseWindow(display, vwin->window);
@@ -681,35 +986,31 @@ static void vwm_win_migrate(vwm_window_t *vwin, vwm_desktop_t *desktop)
 
 
 /* unmanages a managed window (called in response to DestroyNotify) */
-static void vwm_win_unmanage(Window win)
+static void vwm_win_unmanage(vwm_window_t *vwin)
 {
-	vwm_window_t		*vwin;
-
-	VWM_TRACE("unmanaging %x", (unsigned int)win);
-
-	XGrabServer(display);
-	XSync(display, False);
-
-	/* find the window */
-	vwin = vwm_win_lookup(win);
-
-	if(!vwin) {
-		VWM_TRACE("window %x not managed", (unsigned int)win);
-		goto _ungrab;
-	}
-
-	/* unfocus the window */
+#if 0
+/*
+I'm not sure how I feel about this yet, I like the flow of new windows queueing up as the next most recently used and on top of the stack, where I can
+switch to the first one with Mod1-Tab, then destroy them all in sequence, never losing visibility of the next one.
+When this is enabled, that doesn't happen, I see them all stacked on top, switch to the top one and destroy it, then my origin window gets raised and
+focused as it's the truly most recently used window (the last one I committed on and was interacting with before giving attention to the new stack).
+Without this change, it's a nice flow.
+But without this change, odd edge cases emerge where a clearly not MRU window is raised after I destroy something, like the xterm running an mplayer command
+when I switched from the movie window to a new floater xterm momentarily and destroyed it immediately without releasing Mod1.  What happens is the floater xterm
+gets unmanaged on destroy, and the movie window should get focused, but it doesn't, the window _after_ the movie window does, which is the xterm running mplayer,
+because the unfocus() of the floater xterm looked at whatever was after it, since the new floater was inserted immediately after the movie window, it's between
+the movie window and the xterm running mplayer, so the xterm running mplayer gets focused + raised.
+Needs more thought.
+*/
+	vwm_win_mru(vwin); /* bump vwin to the mru head before unfocusing so we always move focus to the current head on unmanage of the focused window */
+#endif
 	vwm_win_unfocus(vwin);
-
-	/* remove the window from the global windows list */
 	list_del(&vwin->windows);
 
-	if(vwin->name) XFree(vwin->name);
+	if(vwin == console) console = NULL;
 
+	if(vwin->name) XFree(vwin->name);
 	free(vwin);
-
-_ungrab:
-	XUngrabServer(display);
 }
 
 
@@ -726,7 +1027,7 @@ static int vwm_manage_existing(void)
 	XQueryTree(display, RootWindow(display, screen_num), &root, &parent, &children, &n_children);
 
 	for(i = 0; i < n_children; i++) {
-		if (children[i] == None) continue;
+		if(children[i] == None) continue;
 
 		if((vwin = vwm_win_manage(children[i], VWM_GRABBED)) == NULL) goto _fail_grabbed;
 	}
@@ -805,18 +1106,12 @@ static void compute_resize(vwm_window_t *vwin, XWindowAttributes *attrs, XEvent
 
 	/* constrain the width and height of the window according to the minimums */
 	if(new->width < min_width) {
-		if(attrs->x != new->x) {
-			new->x -= (min_width - new->width);
-		}
-
+		if(attrs->x != new->x) new->x -= (min_width - new->width);
 		new->width = min_width;
 	}
 
 	if(new->height < min_height) {
-		if(attrs->y != new->y) {
-			new->y -= (min_height - new->height);
-		}
-
+		if(attrs->y != new->y) new->y -= (min_height - new->height);
 		new->height = min_height;
 	}
 }
@@ -831,6 +1126,7 @@ typedef enum _vwm_adjust_mode_t {
 static int vwm_clicked(Window win, XEvent *impetus)
 {
 	XWindowAttributes	orig, lastrect;
+	XWindowChanges		changes = { .border_width = WINDOW_BORDER_WIDTH };
 	vwm_window_t		*vwin;
 
 	/* verify the window still exists */
@@ -838,10 +1134,17 @@ static int vwm_clicked(Window win, XEvent *impetus)
 
 	if(!(vwin = vwm_win_lookup(win))) goto _fail;
 
-	if(impetus->xbutton.state & Mod1Mask) {
+	if(impetus->xbutton.state & WM_GRAB_MODIFIER) {
 		int			finished = 0;
 		vwm_adjust_mode_t	mode;
 
+		/* always set the input focus to the clicked window, note if we allow this to happen on the root window, it enters sloppy focus mode
+		 * until a non-root window is clicked, which is an interesting hybrid but not how I prefer it. */
+		if(vwin != focused_desktop->focused_window && vwin->window != RootWindow(display, screen_num)) {
+			vwm_win_focus(vwin);
+			vwm_win_mru(vwin);
+		}
+
 		switch(impetus->xbutton.button) {
 			case Button1:
 				/* immediately raise the window if we're relocating,
@@ -855,6 +1158,7 @@ static int vwm_clicked(Window win, XEvent *impetus)
 				XGrabServer(display);
 				XSync(display, False);
 
+				/* FIXME: none of the resize DrawRectangle() calls consider the window border. */
 				XDrawRectangle(display, RootWindow(display, screen_num), gc, orig.x, orig.y, orig.width, orig.height);
 				lastrect = orig;
 
@@ -870,21 +1174,25 @@ static int vwm_clicked(Window win, XEvent *impetus)
 			XEvent			event;
 			XWindowAttributes	resized;
 
-			XNextEvent(display, &event);
+			XWindowEvent(display, win, ButtonReleaseMask | PointerMotionMask, &event);
 			switch(event.type) {
 				case ButtonRelease:
 					switch(mode) {
 						case VWM_ADJUST_MOVE:
-							XMoveWindow(display, win,
-									orig.x + (event.xbutton.x_root - impetus->xbutton.x_root),
-									orig.y + (event.xbutton.y_root - impetus->xbutton.y_root));
+							changes.x = orig.x + (event.xmotion.x_root - impetus->xbutton.x_root);
+							changes.y = orig.y + (event.xmotion.y_root - impetus->xbutton.y_root);
+							XConfigureWindow(display, win, CWX | CWY | CWBorderWidth, &changes);
 							break;
 
 						case VWM_ADJUST_RESIZE:
 							compute_resize(vwin, &orig, impetus, &event, &resized);
 							/* move and resize the window @ resized */
 							XDrawRectangle(display, RootWindow(display, screen_num), gc, lastrect.x, lastrect.y, lastrect.width, lastrect.height);
-							XMoveResizeWindow(display, win, resized.x, resized.y, resized.width, resized.height);
+							changes.x = resized.x;
+							changes.y = resized.y;
+							changes.width = resized.width;
+							changes.height = resized.height;
+							XConfigureWindow(display, win, CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &changes);
 							XUngrabServer(display);
 
 							break;
@@ -893,16 +1201,16 @@ static int vwm_clicked(Window win, XEvent *impetus)
 							break;
 					}
 					/* once you manipulate the window it's no longer fullscreened, simply hitting Mod1+Return once will restore fullscreened mode */
-					vwin->fullscreened = 0;
+					vwin->autoconfigured = VWM_WIN_AUTOCONF_NONE;
 					finished = 1;
 					break;
 
 				case MotionNotify:
 					switch(mode) {
 						case VWM_ADJUST_MOVE:
-							XMoveWindow(display, win,
-									orig.x + (event.xmotion.x_root - impetus->xbutton.x_root),
-									orig.y + (event.xmotion.y_root - impetus->xbutton.y_root));
+							changes.x = orig.x + (event.xmotion.x_root - impetus->xbutton.x_root);
+							changes.y = orig.y + (event.xmotion.y_root - impetus->xbutton.y_root);
+							XConfigureWindow(display, win, CWX | CWY | CWBorderWidth, &changes);
 							break;
 
 						case VWM_ADJUST_RESIZE:
@@ -929,13 +1237,6 @@ static int vwm_clicked(Window win, XEvent *impetus)
 		}
 	}
 
-	/* always set the input focus to the clicked window, note if we allow this to happen on the root window, it enters sloppy focus mode
-	 * until a non-root window is clicked, which is an interesting hybrid but not how I prefer it. */
-	if(vwin != focused_desktop->focused_window && vwin->window != RootWindow(display, screen_num)) {
-		vwm_win_focus(vwin);
-		vwm_win_mru(vwin);
-	}
-
 	XFlush(display);
 	XUngrabPointer(display, CurrentTime);
 
@@ -960,19 +1261,16 @@ static void vwm_keyreleased(Window win, XEvent *keyrelease)
 		case XK_Alt_L:	/* TODO: actually use the modifier mapping, for me XK_Alt_[LR] is Mod1.  XGetModifierMapping()... */
 			VWM_TRACE("XK_Alt_[LR] released");
 			/* make the focused window the most recently used */
-			if((vwin = vwm_win_focused())) {
-				vwm_win_mru(vwin);
-			}
+			if((vwin = vwm_win_focused())) vwm_win_mru(vwin);
 
 			/* make the focused desktop the most recently used */
-			if(focused_context == VWM_CONTEXT_FOCUS_DESKTOP && focused_desktop) {
-				vwm_desktop_mru(focused_desktop);
-			}
+			if(focused_context == VWM_CONTEXT_FOCUS_DESKTOP && focused_desktop) vwm_desktop_mru(focused_desktop);
 
 			if(key_is_grabbed) {
 				XUngrabKeyboard(display, CurrentTime);
 				XFlush(display);
 				key_is_grabbed = 0;
+				fence_mask = 0;	/* reset the fence mask on release for VWM_FENCE_MASKED_VIOLATE */
 			}
 			break;
 
@@ -986,16 +1284,20 @@ static void vwm_keyreleased(Window win, XEvent *keyrelease)
 /* Called in response to KeyPress events, I currenly only grab Mod1 keypress events */
 static void vwm_keypressed(Window win, XEvent *keypress)
 {
-	vwm_window_t	*vwin;
-	KeySym		sym;
-	static KeySym	last_sym;
-	static int	repeat_cnt = 0;
-	int		do_grab = 0;
+	vwm_window_t				*vwin;
+	KeySym					sym;
+	static KeySym				last_sym;
+	static typeof(keypress->xkey.state)	last_state;
+	static int				repeat_cnt = 0;
+	int					do_grab = 0;
+#ifdef QUIT_CONSOLE_ON_EXIT
+	char					*quit_console_args[] = {"bash", "-c", "screen -dr " CONSOLE_SESSION_STRING " -X quit", NULL};
+#endif
 
 	sym = XLookupKeysym(&keypress->xkey, 0);
 
 	/* detect repeaters, note repeaters do not span interrupted Mod1 sequences! */
-	if(key_is_grabbed && sym == last_sym) {
+	if(key_is_grabbed && sym == last_sym && keypress->xkey.state == last_state) {
 		repeat_cnt++;
 	} else {
 		repeat_cnt = 0;
@@ -1003,11 +1305,11 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 
 	switch(sym) {
 
-#define launcher(_sym, _argv...)\
+#define launcher(_sym, _label, _argv)\
 		case _sym:	\
 			{	\
-			char	*args[] = {_argv, NULL};\
-			vwm_launch(args);\
+			char	*args[] = {"bash", "-c", "screen -dr " CONSOLE_SESSION_STRING " -X screen bash -i -x -c \"" _argv " || sleep 86400\"", NULL};\
+			vwm_launch(args, VWM_LAUNCH_MODE_BG);\
 			break;	\
 		}
 #include "launchers.def"
@@ -1018,20 +1320,31 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 			break;
 
 		case XK_Tab: /* cycle focused window */
-			do_grab = 1; /* grab the keyboard so we can respond to the Mod1 release */
+			do_grab = 1; /* update MRU window on commit (Mod1 release) */
 
-			/* focus the next window, note this doesn't affect MRU, that happens on Mod1 release */
+			/* focus the next window, note this doesn't affect MRU yet, that happens on Mod1 release */
 			if((vwin = vwm_win_focused())) {
-				vwm_win_focus_next(vwin, focused_context);
+				if(keypress->xkey.state & ShiftMask) {
+					vwm_win_focus_next(vwin, focused_context, VWM_FENCE_MASKED_VIOLATE);
+				} else {
+					vwm_win_focus_next(vwin, focused_context, VWM_FENCE_RESPECT);
+				}
 			}
 			break;
 
-		case XK_space: /* cycle focused desktop utilizing MRU */
-			do_grab = 1; /* grab the keyboard so we can respond to the Mod1 release for MRU updating */
+		case XK_space: { /* cycle focused desktop utilizing MRU */
+			vwm_desktop_t	*next_desktop = list_entry(focused_desktop->desktops_mru.next == &desktops_mru ? focused_desktop->desktops_mru.next->next : focused_desktop->desktops_mru.next, vwm_desktop_t, desktops_mru); /* XXX: note the sensitivity to the desktops_mru head here, we want to look past it. */
 
-			/* XXX: note the sensitivity to the desktops_mru head here, we want to look past it. */
-			vwm_desktop_focus(list_entry(focused_desktop->desktops_mru.next == &desktops_mru ? focused_desktop->desktops_mru.next->next : focused_desktop->desktops_mru.next, vwm_desktop_t, desktops_mru));
+			do_grab = 1; /* update MRU desktop on commit (Mod1 release) */
+
+			if(keypress->xkey.state & ShiftMask) {
+				/* migrate the focused window with the desktop focus to the most recently used desktop */
+				if((vwin = vwm_win_focused())) vwm_win_migrate(vwin, next_desktop);
+			} else {
+				vwm_desktop_focus(next_desktop);
+			}
 			break;
+		}
 
 		case XK_d: /* destroy focused */
 			if((vwin = vwm_win_focused())) {
@@ -1046,10 +1359,20 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 			}
 			break;
 
-		case XK_Escape: /* leave VWM rudely */
-			exit(42);
+		case XK_Escape: /* leave VWM rudely, after triple press */
+			do_grab = 1;
+
+			if(repeat_cnt == 2) {
+#ifdef QUIT_CONSOLE_ON_EXIT
+				vwm_launch(quit_console_args, VWM_LAUNCH_MODE_FG);
+#endif
+				exit(42);
+			}
+			break;
 
 		case XK_v: /* instantiate (and focus) a new (potentially empty, unless migrating) virtual desktop */
+			do_grab = 1; /* update MRU desktop on commit (Mod1 release) */
+
 			if(keypress->xkey.state & ShiftMask) {
 				if((vwin = vwm_win_focused())) {
 					/* migrate the focused window to a newly created virtual desktop, focusing the new desktop simultaneously */
@@ -1062,7 +1385,7 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 			break;
 
 		case XK_h: /* previous virtual desktop, if we're in the shelf context this will simply switch to desktop context */
-			do_grab = 1; /* grab the keyboard so we can respond to the Mod1 release for MRU updating */
+			do_grab = 1; /* update MRU desktop on commit (Mod1 release) */
 
 			if(keypress->xkey.state & ShiftMask) {
 				if((vwin = vwm_win_focused()) && vwin->desktop->desktops.prev != &desktops) {
@@ -1081,7 +1404,7 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 			break;
 
 		case XK_l: /* next virtual desktop, if we're in the shelf context this will simply switch to desktop context */
-			do_grab = 1; /* grab the keyboard so we can respond to the Mod1 release for MRU updating */
+			do_grab = 1; /* update MRU desktop on commit (Mod1 release) */
 
 			if(keypress->xkey.state & ShiftMask) {
 				if((vwin = vwm_win_focused()) && vwin->desktop->desktops.next != &desktops) {
@@ -1114,10 +1437,18 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 
 					if(repeat_cnt == 1) {
 						/* double: reraise & fullscreen */
-						vwm_win_fullscreen(vwin);
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_FULL);
 					} else if(repeat_cnt == 2) {
 						 /* triple: reraise & fullscreen w/borders obscured by screen perimiter */
-						vwm_win_allscreen(vwin);
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_ALL);
+					} else if(xinerama_screens_cnt > 1) {
+						if(repeat_cnt == 3) {
+							 /* triple: reraise & fullscreen across all screens */
+							vwm_win_autoconf(vwin, VWM_SCREEN_REL_TOTAL, VWM_WIN_AUTOCONF_FULL);
+						} else if(repeat_cnt == 4) {
+							 /* quadruple: reraise & fullscreen w/borders obscured by screen perimiter */
+							vwm_win_autoconf(vwin, VWM_SCREEN_REL_TOTAL, VWM_WIN_AUTOCONF_ALL);
+						}
 					}
 					XFlush(display);
 				}
@@ -1132,8 +1463,8 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 						vwm_win_migrate(vwin, focused_desktop);
 					}
 				} else {
-					if(vwin->fullscreened == 2) {
-						vwm_win_fullscreen(vwin);
+					if(vwin->autoconfigured == VWM_WIN_AUTOCONF_ALL) {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_FULL);
 					} else {
 						XLowerWindow(display, vwin->window);
 					}
@@ -1144,17 +1475,55 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 
 		case XK_Return: /* (full-screen / restore) focused window */
 			if((vwin = vwm_win_focused())) {
-				if(vwin->fullscreened) {
-					vwm_win_restore(vwin);
+				if(vwin->autoconfigured) {
+					vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_NONE);
 				} else {
-					vwm_win_fullscreen(vwin);
+					vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_FULL);
 				}
 			}
 			break;
 
 		case XK_s: /* shelve focused window */
-			if((vwin = vwm_win_focused()) && !vwin->shelved) {
-				vwm_win_shelve(vwin);
+			if((vwin = vwm_win_focused()) && !vwin->shelved) vwm_win_shelve(vwin);
+			break;
+
+		case XK_bracketleft:	/* reconfigure the focused window to occupy the left or top half of the screen or left quarters on repeat */
+			if((vwin = vwm_win_focused())) {
+				do_grab = 1;
+
+				if(keypress->xkey.state & ShiftMask) {
+					if(!repeat_cnt) {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_HALF, VWM_SIDE_TOP);
+					} else {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_QUARTER, VWM_CORNER_TOP_LEFT);
+					}
+				} else {
+					if(!repeat_cnt) {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_HALF, VWM_SIDE_LEFT);
+					} else {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_QUARTER, VWM_CORNER_BOTTOM_LEFT);
+					}
+				}
+			}
+			break;
+
+		case XK_bracketright:	/* reconfigure the focused window to occupy the right or bottom half of the screen or right quarters on repeat */
+			if((vwin = vwm_win_focused())) {
+				do_grab = 1;
+
+				if(keypress->xkey.state & ShiftMask) {
+					if(!repeat_cnt) {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_HALF, VWM_SIDE_BOTTOM);
+					} else {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_QUARTER, VWM_CORNER_BOTTOM_RIGHT);
+					}
+				} else {
+					if(!repeat_cnt) {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_HALF, VWM_SIDE_RIGHT);
+					} else {
+						vwm_win_autoconf(vwin, VWM_SCREEN_REL_WINDOW, VWM_WIN_AUTOCONF_QUARTER, VWM_CORNER_TOP_RIGHT);
+					}
+				}
 			}
 			break;
 
@@ -1163,7 +1532,7 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 			break;
 	}
 
-	/* if what we're doing requests a grab if not already grabbed, grab keyboard */
+	/* if what we're doing requests a grab, if not already grabbed, grab keyboard */
 	if(!key_is_grabbed && do_grab) {
 		XGrabKeyboard(display, RootWindow(display, screen_num), False, GrabModeAsync, GrabModeAsync, CurrentTime);
 		key_is_grabbed = 1;
@@ -1171,6 +1540,7 @@ static void vwm_keypressed(Window win, XEvent *keypress)
 
 	/* remember the symbol for repeater detection */
 	last_sym = sym;
+	last_state = keypress->xkey.state;
 }
 
 
@@ -1179,29 +1549,48 @@ static int errhandler(Display *display, XErrorEvent *err)
 	/* TODO */
 	return 1;
 }
- 
+
 int main(int argc, char *argv[])
 {
-	int			done = 0;
-	XEvent			event;
-	Cursor			pointer;
+	int	err = 0;
+	int	done = 0;
+	XEvent	event;
+	Cursor	pointer;
+	char	*console_args[] = {"xterm", "-class", CONSOLE_WM_CLASS, "-e", "bash", "-c", "screen -D -RR " CONSOLE_SESSION_STRING, NULL};
+
+#define reterr_if(_cond, _fmt, _args...) \
+	err++;\
+	if(_cond) {\
+		VWM_ERROR(_fmt, ##_args);\
+		return err;\
+	}
 
 	/* open connection with the server */
-	if((display = XOpenDisplay(NULL)) == NULL) {
-		VWM_ERROR("Cannot open display");
-		return 1;
-	}
+	reterr_if((display = XOpenDisplay(NULL)) == NULL, "Cannot open display");
 
 	/* prevent children from inheriting the X connection */
-	if(fcntl(ConnectionNumber(display), F_SETFD, FD_CLOEXEC) < 0) {
-		VWM_ERROR("Cannot set FD_CLOEXEC on X connection");
-		return 2;
-	}
+	reterr_if(fcntl(ConnectionNumber(display), F_SETFD, FD_CLOEXEC) < 0, "Cannot set FD_CLOEXEC on X connection");
+
+	/* get our scheduling priority, clients are launched with a priority LAUNCHED_RELATIVE_PRIORITY nicer than this */
+	reterr_if((priority = getpriority(PRIO_PROCESS, getpid())) == -1, "Cannot get scheduling priority");
 
 	XSetErrorHandler(errhandler);
 
 	screen_num = DefaultScreen(display);
 
+	if(XSyncQueryExtension(display, &sync_event, &sync_error)) {
+		/* set the window manager to the maximum X client priority */
+		XSyncSetPriority(display, RootWindow(display, screen_num), 0x7fffffff);
+	}
+
+	if(XineramaQueryExtension(display, &xinerama_event, &xinerama_error)) {
+		xinerama_screens = XineramaQueryScreens(display, &xinerama_screens_cnt);
+	}
+
+	if(XRRQueryExtension(display, &randr_event, &randr_error)) {
+		XRRSelectInput(display, RootWindow(display, screen_num), RRScreenChangeNotifyMask);
+	}
+
 	/* allocate colors, I make assumptions about the X server's color capabilities since I'll only use this on modern-ish computers... */
 	cmap = DefaultColormap(display, screen_num);
 
@@ -1213,13 +1602,18 @@ int main(int argc, char *argv[])
 	wm_delete_atom = XInternAtom(display, "WM_DELETE_WINDOW", False);
 	wm_protocols_atom = XInternAtom(display, "WM_PROTOCOLS", False);
 
-	XSelectInput(display, RootWindow(display, screen_num), SubstructureNotifyMask | SubstructureRedirectMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask);
-	XGrabKey(display, AnyKey, Mod1Mask, RootWindow(display, screen_num), False, GrabModeAsync, GrabModeAsync);
+	XSelectInput(display, RootWindow(display, screen_num),
+		     SubstructureNotifyMask | SubstructureRedirectMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask);
+	XGrabKey(display, AnyKey, WM_GRAB_MODIFIER, RootWindow(display, screen_num), False, GrabModeAsync, GrabModeAsync);
 
 	XFlush(display);
 
 	XSetInputFocus(display, RootWindow(display, screen_num), RevertToPointerRoot, CurrentTime);
 
+	/* create initial virtual desktop */
+	vwm_desktop_focus(vwm_desktop_create(NULL));
+	vwm_desktop_mru(focused_desktop);
+
 	/* manage all preexisting windows */
 	vwm_manage_existing();
 
@@ -1228,6 +1622,9 @@ int main(int argc, char *argv[])
 	XSetSubwindowMode(display, gc, IncludeInferiors);
 	XSetFunction(display, gc, GXxor);
 
+	/* launch the console here so it's likely ready by the time the logo animation finishes (there's no need to synchronize with it currently) */
+	vwm_launch(console_args, VWM_LAUNCH_MODE_BG);
+
 	/* first the logo color is the foreground */
 	XSetForeground(display, gc, logo_color.pixel);
 	vwm_draw_logo();
@@ -1242,13 +1639,9 @@ int main(int argc, char *argv[])
 	XDefineCursor(display, RootWindow(display, screen_num), pointer);
 
 	/* event loop */
-	while (!done) {
+	while(!done) {
 		XNextEvent(display, &event);
-		switch (event.type) {
-			case Expose:
-				VWM_TRACE("expose");
-				break;
-
+		switch(event.type) {
 			case KeyPress:
 				VWM_TRACE("keypress");
 				vwm_keypressed(event.xkey.window, &event);
@@ -1264,47 +1657,15 @@ int main(int argc, char *argv[])
 				vwm_clicked(event.xbutton.window, &event);
 				break;
 
-			case ButtonRelease:
-				VWM_TRACE("buttonrelease");
-				break;
 
-			case DestroyNotify:
+			case DestroyNotify: {
+				vwm_window_t	*vwin;
 				VWM_TRACE("destroynotify");
-				vwm_win_unmanage(event.xdestroywindow.window);
-				break;
-
-			case CirculateNotify:
-				VWM_TRACE("circulatenotify");
-				break;
-
-			case ConfigureNotify:
-				VWM_TRACE("configurenotify");
-				break;
-
-			case UnmapNotify:
-				VWM_TRACE("unmapnotify");
-				break;
-
-			case CreateNotify:
-				VWM_TRACE("createnotify");
-				vwm_win_manage(event.xcreatewindow.window, VWM_NOT_GRABBED);
-				break;
-
-			case GravityNotify:
-				VWM_TRACE("gravitynotify");
-				break;
-
-			case MapNotify:
-				VWM_TRACE("mapnotify");
-				break;
-
-			case ReparentNotify:
-				VWM_TRACE("reparentnotify");
-				break;
-
-			case MotionNotify:
-				VWM_TRACE("motionnotify");
+				if((vwin = vwm_win_lookup(event.xdestroywindow.window))) {
+					vwm_win_unmanage(vwin);
+				}
 				break;
+			}
 
 			case ConfigureRequest: {
 				XWindowChanges	changes = {
@@ -1314,45 +1675,122 @@ int main(int argc, char *argv[])
 							.height = event.xconfigurerequest.height,
 							.border_width = WINDOW_BORDER_WIDTH /* except I do override whatever the border width may be */
 						};
-
+				unsigned long	change_mask = (event.xconfigurerequest.value_mask & (CWX | CWY | CWWidth | CWHeight)) | CWBorderWidth;
+				/* XXX: windows raising themselves is annoying, so discard CWSibling and CWStackMode. */
 				VWM_TRACE("configurerequest x=%i y=%i w=%i h=%i", changes.x, changes.y, changes.width, changes.height);
-				XConfigureWindow(display, event.xconfigurerequest.window, (event.xconfigurerequest.value_mask | CWBorderWidth), &changes);
+				XConfigureWindow(display, event.xconfigurerequest.window, change_mask, &changes);
 				break;
 			}
 
-			case MapRequest: {
+			case ConfigureNotify: {
 				vwm_window_t	*vwin;
+				VWM_TRACE("configurenotify");
+				if((vwin = vwm_win_lookup(event.xconfigure.window))) {
+					vwin->config.x = event.xconfigure.x;
+					vwin->config.y = event.xconfigure.y;
+					vwin->config.width = event.xconfigure.width;
+					vwin->config.height = event.xconfigure.height;
+				}
+				break;
+			}
 
-				VWM_TRACE("maprequest");
+			case UnmapNotify: {
+				vwm_window_t	*vwin;
+				VWM_TRACE("unmapnotify");
+				/* unlike MapRequest, we simply are notified when a window is unmapped. */
+				if((vwin = vwm_win_lookup(event.xunmap.window))) {
+					if(vwin->unmapping) {
+						VWM_TRACE("swallowed vwm-induced UnmapNotify");
+						vwin->unmapping = 0;
+					} else {
+						vwm_win_unmanage(vwin);
+					}
+				}
+				break;
+			}
+
+			case MapNotify: {
+				vwm_window_t	*vwin;
+				VWM_TRACE("mapnotify");
+				if(!(vwin = vwm_win_lookup(event.xmap.window))) {
+					/* unmanaged windows becoming mapped arrive here, popups/menus and the like, if they
+					 * don't want to be managed they'll set override_redirect, which will be ignored or honored depending on
+					 * HONOR_OVERRIDE_REDIRECT, if we honor it this generally becomes a noop. */
+					vwm_win_manage(event.xmap.window, VWM_NOT_GRABBED);
+				} else {
+					VWM_TRACE("swallowed vwm-induced MapNotify");
+				}
+				break;
+			}
 
-				vwin = vwm_win_lookup(event.xmap.window);
-				if(vwin && !vwin->mapped) {
-					int			x = 0, y = 0;
+			case MapRequest: {
+				vwm_window_t	*vwin;
+				int		domap = 1;
+				VWM_TRACE("maprequest");
+				if((vwin = vwm_win_lookup(event.xmap.window)) || (vwin = vwm_win_manage(event.xmap.window, VWM_NOT_GRABBED))) {
 					XWindowAttributes	attrs;
-					XWindowChanges		changes;
+					XWindowChanges		changes = {.x = 0, .y = 0};
+					XClassHint		*classhint;
+					const vwm_screen_t	*scr;
+
+					/* figure out if the window is the console */
+					if((classhint = XAllocClassHint())) {
+						if(XGetClassHint(display, event.xmap.window, classhint) && !strcmp(classhint->res_class, CONSOLE_WM_CLASS)) {
+							console = vwin;
+							vwm_win_shelve(vwin);
+							domap = 0;
+						}
+
+						if(classhint->res_class) XFree(classhint->res_class);
+						if(classhint->res_name) XFree(classhint->res_name);
+						XFree(classhint);
+					}
+
+					/* TODO: this is a good place to hook in a window placement algo */
 
-					/* on initial mapping of a window we discover the coordinates and dimensions of the window */
-					changes.x = x;
-					changes.y = y;
+					/* on client-requested mapping we place the window */
+					if(!vwin->shelved) {
+						/* we place the window on the screen containing the the pointer only if that screen is empty,
+						 * otherwise we place windows on the screen containing the currently focused window */
+						/* since we query the geometry of windows in determining where to place them, a configuring
+						 * flag is used to exclude the window being configured from those queries */
+						scr = vwm_screen_find(VWM_SCREEN_REL_POINTER);
+						vwin->configuring = 1;
+						if(vwm_screen_is_empty(scr)) {
+							/* focus the new window if it isn't already focused when it's going to an empty screen */
+							VWM_TRACE("window \"%s\" is alone on screen \"%i\", focusing", vwin->name, scr->screen_number);
+							vwm_win_focus(vwin);
+						} else {
+							scr = vwm_screen_find(VWM_SCREEN_REL_WINDOW, focused_desktop->focused_window);
+						}
+						vwin->configuring = 0;
+
+						changes.x = scr->x_org;
+						changes.y = scr->y_org;
+					} else if(focused_context == VWM_CONTEXT_FOCUS_SHELF) {
+						scr = vwm_screen_find(VWM_SCREEN_REL_WINDOW, focused_shelf);
+						changes.x = scr->x_org;
+						changes.y = scr->y_org;
+					}
 
-					vwin->mapped = 1;
 					XGetWMNormalHints(display, event.xmap.window, vwin->hints, &vwin->hints_supplied);
 					XGetWindowAttributes(display, event.xmap.window, &attrs);
 
-					/* TODO: this is a good place to hook in a window placement algo */
-					vwin->client.x = x;
-					vwin->client.y = y;
+					vwin->client.x = changes.x;
+					vwin->client.y = changes.y;
 
 					vwin->client.height = attrs.height;
 					vwin->client.width = attrs.width;
 
 					XConfigureWindow(display, event.xmap.window, (CWX | CWY), &changes);
 				}
-				
-				XMapWindow(display, event.xmap.window);
-				if(vwin->desktop->focused_window == vwin) {
-					XSync(display, False);
-					XSetInputFocus(display, vwin->window, RevertToPointerRoot, CurrentTime);
+			
+				if(domap) {
+					XMapWindow(display, event.xmap.window);
+					if(vwin && vwin->desktop->focused_window == vwin) {
+						XSync(display, False);
+						XSetInputFocus(display, vwin->window, RevertToPointerRoot, CurrentTime);
+					}
 				}
 				break;
 			}
@@ -1362,8 +1800,35 @@ int main(int argc, char *argv[])
 				XRefreshKeyboardMapping(&event.xmapping);
 				break;
 
+			case ButtonRelease:
+				VWM_TRACE("buttonrelease");
+				break;
+			case CirculateNotify:
+				VWM_TRACE("circulatenotify");
+				break;
+			case CreateNotify:
+				VWM_TRACE("createnotify");
+				break;
+			case Expose:
+				VWM_TRACE("expose");
+				break;
+			case GravityNotify:
+				VWM_TRACE("gravitynotify");
+				break;
+			case MotionNotify:
+				VWM_TRACE("motionnotify");
+				break;
+			case ReparentNotify:
+				VWM_TRACE("reparentnotify");
+				break;
 			default:
-				VWM_ERROR("Unhandled X op %i", event.type);
+				if(event.type == randr_event + RRScreenChangeNotify) {
+					VWM_TRACE("rrscreenchangenotify");
+					if(xinerama_screens) XFree(xinerama_screens);
+					xinerama_screens = XineramaQueryScreens(display, &xinerama_screens_cnt);
+				} else {
+					VWM_ERROR("Unhandled X op %i", event.type);
+				}
 				break;
 		}
 	}