First commit

This is the original state of the released tarball for JWM 1.8,
which will serve as my starting point for further modifications.

90 files changed, 23581 insertions, 0 deletions

diff --git a/src/Makefile.in b/src/Makefile.in
new file mode 100644
index 0000000..8b73c8d
--- /dev/null
+++ b/src/Makefile.in
@@ -0,0 +1,38 @@
+
+CC = @CC@
+CFLAGS = @CFLAGS@
+LDFLAGS = @LDFLAGS@
+BINDIR = @BINDIR@
+
+VPATH=.:os
+
+OBJECTS = border.o button.o client.o clock.o color.o command.o confirm.o \
+	cursor.o debug.o desktop.o dock.o event.o error.o font.o group.o help.o \
+	hint.o icon.o image.o key.o lex.o main.o match.o menu.o misc.o move.o \
+	outline.o pager.o parse.o place.o popup.o render.o resize.o root.o \
+	screen.o status.o swallow.o taskbar.o theme.o timing.o tray.o \
+	traybutton.o winmenu.o
+
+EXE = jwm
+
+.SUFFIXES: .o .h .c
+
+all: $(EXE)
+
+install: all
+	strip $(EXE)
+	install -d $(BINDIR)
+	install $(EXE) $(BINDIR)/$(EXE)
+
+depend:
+	makedepend -m -- $(CFLAGS) -- *.c
+
+$(EXE): $(OBJECTS)
+	$(CC) -o $(EXE) $(OBJECTS) $(LDFLAGS)
+
+.c.o:
+	$(CC) -c $(CFLAGS) $<
+
+clean:
+	rm -f $(OBJECTS) $(EXE) core
+
diff --git a/src/border.c b/src/border.c
new file mode 100644
index 0000000..8baf7b7
--- /dev/null
+++ b/src/border.c
@@ -0,0 +1,753 @@
+/****************************************************************************
+ * Functions for dealing with window borders.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "border.h"
+#include "client.h"
+#include "color.h"
+#include "main.h"
+#include "icon.h"
+#include "font.h"
+#include "error.h"
+
+typedef enum {
+	BP_CLOSE,
+	BP_ACTIVE_CLOSE,
+	BP_MINIMIZE,
+	BP_ACTIVE_MINIMIZE,
+	BP_MAXIMIZE,
+	BP_ACTIVE_MAXIMIZE,
+	BP_MAXIMIZE_ACTIVE,
+	BP_ACTIVE_MAXIMIZE_ACTIVE,
+	BP_COUNT
+} BorderPixmapType;
+
+typedef unsigned char BorderPixmapDataType[32];
+
+static BorderPixmapDataType bitmaps[BP_COUNT >> 1] = {
+
+	/* Close */
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x38, 0x38, 0x70, 0x1C,
+	  0xE0, 0x0E, 0xC0, 0x07, 0x80, 0x03, 0xC0, 0x07, 0xE0, 0x0E, 0x70, 0x1C,
+	  0x38, 0x38, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00 },
+
+	/* Minimize */
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x07,
+	  0xF8, 0x07, 0xF8, 0x07, 0x00, 0x00, 0x00, 0x00 },
+
+	/* Maximize */
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF8, 0x3F, 0xF8, 0x3F, 0xF8, 0x3F,
+	  0x08, 0x20, 0x08, 0x20, 0x08, 0x20, 0x08, 0x20, 0x08, 0x20, 0x08, 0x20,
+	  0x08, 0x20, 0xF8, 0x3F, 0x00, 0x00, 0x00, 0x00 },
+
+	/* Maximize Active */
+	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x1F, 0xC0, 0x1F,
+	  0x00, 0x10, 0xF8, 0x13, 0xF8, 0x13, 0x08, 0x12, 0x08, 0x1A, 0x08, 0x02,
+	  0x08, 0x02, 0xF8, 0x03, 0x00, 0x00, 0x00, 0x00 }
+
+};
+
+static Pixmap pixmaps[BP_COUNT];
+
+static Region borderRegion = NULL;
+static GC borderGC;
+
+static void DrawBorderHelper(const ClientNode *np,
+	unsigned int width, unsigned int height, int drawIcon);
+static void DrawButtonBorder(const ClientNode *np, int offset,
+	Pixmap canvas, GC gc);
+static int DrawBorderButtons(const ClientNode *np, Pixmap canvas, GC gc);
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeBorders() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupBorders() {
+
+	XGCValues gcValues;
+	unsigned long gcMask;
+	long fg, bg;
+	int x;
+
+	for(x = 0; x < BP_COUNT; x++) {
+
+		if(x & 1) {
+			fg = colors[COLOR_BORDER_ACTIVE_FG];
+			bg = colors[COLOR_BORDER_ACTIVE_BG];
+		} else {
+			fg = colors[COLOR_BORDER_FG];
+			bg = colors[COLOR_BORDER_BG];
+		}
+
+		pixmaps[x] = JXCreatePixmapFromBitmapData(display, rootWindow,
+			(char*)bitmaps[x >> 1], 16, 16, fg, bg, rootDepth);
+
+	}
+
+	gcMask = GCGraphicsExposures;
+	gcValues.graphics_exposures = False;
+	borderGC = JXCreateGC(display, rootWindow, gcMask, &gcValues);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownBorders() {
+
+	int x;
+
+	JXFreeGC(display, borderGC);
+
+	for(x = 0; x < BP_COUNT; x++) {
+		JXFreePixmap(display, pixmaps[x]);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyBorders() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetBorderIconSize() {
+	return titleHeight - 4;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+BorderActionType GetBorderActionType(const ClientNode *np, int x, int y) {
+
+	int north;
+	int offset;
+	int height, width;
+	int bsize;
+
+	Assert(np);
+
+	if(np->state.border & BORDER_OUTLINE) {
+		bsize = borderWidth;
+	} else {
+		bsize = 0;
+	}
+
+	if(np->state.border & BORDER_TITLE) {
+
+		if(y > bsize && y <= bsize + titleHeight) {
+			if(np->icon && np->width >= titleHeight) {
+				if(x > bsize && x < bsize + titleHeight) {
+					return BA_MENU;
+				}
+			}
+			offset = np->width + bsize - titleHeight;
+			if((np->state.border & BORDER_CLOSE)
+				&& offset > bsize + titleHeight) {
+				if(x > offset && x < offset + titleHeight) {
+					return BA_CLOSE;
+				}
+				offset -= titleHeight;
+			}
+			if((np->state.border & BORDER_MAX)
+				&& offset > bsize + titleHeight) {
+				if(x > offset && x < offset + titleHeight) {
+					return BA_MAXIMIZE;
+				}
+				offset -= titleHeight;
+			}
+			if((np->state.border & BORDER_MIN) && offset > bsize + titleHeight) {
+				if(x > offset && x < offset + titleHeight) {
+					return BA_MINIMIZE;
+				}
+			}
+		}
+
+		if(y >= bsize && y <= bsize + titleHeight) {
+			if(x >= bsize && x <= np->width + bsize) {
+				if(np->state.border & BORDER_MOVE) {
+					return BA_MOVE;
+				} else {
+					return BA_NONE;
+				}
+			}
+		}
+
+		north = bsize + titleHeight;
+	} else {
+		north = bsize;
+	}
+
+	if(!(np->state.border & BORDER_RESIZE)) {
+		return BA_NONE;
+	}
+
+	width = np->width;
+
+	if(np->state.status & STAT_SHADED) {
+		if(x < bsize) {
+			return BA_RESIZE_W | BA_RESIZE;
+		} else if(x >= width + bsize) {
+			return BA_RESIZE_E | BA_RESIZE;
+		} else {
+			return BA_NONE;
+		}
+	}
+
+	height = np->height;
+
+	if(width >= titleHeight * 2 && height >= titleHeight * 2) {
+		if(x < bsize + titleHeight && y < titleHeight + bsize) {
+			return  BA_RESIZE_N | BA_RESIZE_W | BA_RESIZE;
+		} else if(x < titleHeight + bsize
+			&& y - north >= height - titleHeight) {
+			return BA_RESIZE_S | BA_RESIZE_W | BA_RESIZE;
+		} else if(x - bsize >= width - titleHeight
+			&& y < titleHeight + bsize) {
+			return BA_RESIZE_N | BA_RESIZE_E | BA_RESIZE;
+		} else if(x - bsize >= width - titleHeight
+			&& y - north >= height - titleHeight) {
+			return BA_RESIZE_S | BA_RESIZE_E | BA_RESIZE;
+		}
+	}
+	if(x < bsize) {
+		return BA_RESIZE_W | BA_RESIZE;
+	} else if(x >= width + bsize) {
+		return BA_RESIZE_E | BA_RESIZE;
+	} else if(y < bsize) {
+		return BA_RESIZE_N | BA_RESIZE;
+	} else if(y >= height) {
+		return BA_RESIZE_S | BA_RESIZE;
+	} else {
+		return BA_NONE;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DrawBorder(const ClientNode *np, const XExposeEvent *expose) {
+
+	XRectangle rect;
+	unsigned int width;
+	unsigned int height;
+	int bsize;
+	int drawIcon;
+	int temp;
+
+	Assert(np);
+
+	if(shouldExit) {
+		return;
+	}
+
+	if(!(np->state.status & (STAT_MAPPED | STAT_SHADED))) {
+		return;
+	}
+	if(np->state.status & (STAT_HIDDEN | STAT_FULLSCREEN)) {
+		return;
+	}
+
+	if(np->state.border & BORDER_OUTLINE) {
+		bsize = borderWidth;
+	} else {
+		bsize = 0;
+	}
+
+	if(bsize == 0 && !(np->state.border & BORDER_TITLE)) {
+		return;
+	}
+
+	if(expose) {
+
+		if(!borderRegion) {
+			borderRegion = XCreateRegion();
+		}
+
+		rect.x = (short)expose->x;
+		rect.y = (short)expose->y;
+		rect.width = (unsigned short)expose->width;
+		rect.height = (unsigned short)expose->height;
+		XUnionRectWithRegion(&rect, borderRegion, borderRegion);
+
+		if(expose->count) {
+			return;
+		}
+
+		/* Determine if the icon should be redrawn. This is needed
+		 * since icons need a separate GC for applying shape masks.
+		 * Note that if the icon were naively redrawn, icons with
+		 * alpha channels would acquire artifacts since the area under
+		 * them would not be cleared. So if any part of the icon needs
+		 * to be redrawn, we clear the area and redraw the whole icon.
+		 */
+		drawIcon = 0;
+		temp = GetBorderIconSize();
+		rect.x = (short)bsize + 2;
+		rect.y = (short)(bsize + titleHeight / 2 - temp / 2);
+		rect.width = (unsigned short)temp;
+		rect.height = (unsigned short)temp;
+		if(XRectInRegion(borderRegion, rect.x, rect.y, rect.width, rect.height)
+			!= RectangleOut) {
+
+			drawIcon = 1;
+			XUnionRectWithRegion(&rect, borderRegion, borderRegion);
+
+		} else {
+
+			drawIcon = 0;
+
+		}
+
+		XSetRegion(display, borderGC, borderRegion);
+
+	} else {
+
+		drawIcon = 1;
+		XSetClipMask(display, borderGC, None);
+
+	}
+
+	if(np->state.status & STAT_SHADED) {
+		height = titleHeight + bsize * 2;
+	} else if(np->state.border & BORDER_TITLE) {
+		height = np->height + titleHeight + bsize * 2;
+	} else {
+		height = np->height + 2 * bsize;
+	}
+	width = np->width + bsize * 2;
+
+	DrawBorderHelper(np, width, height, drawIcon);
+
+	if(expose) {
+		XDestroyRegion(borderRegion);
+		borderRegion = NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DrawBorderHelper(const ClientNode *np,
+	unsigned int width, unsigned int height, int drawIcon) {
+
+	ColorType borderTextColor;
+	long borderPixel, borderTextPixel;
+	long pixelUp, pixelDown;
+	int buttonCount, titleWidth;
+	Pixmap canvas;
+	GC gc;
+	int iconSize;
+	int bsize;
+
+	Assert(np);
+
+	iconSize = GetBorderIconSize();
+
+	if(np->state.status & STAT_ACTIVE) {
+		borderTextColor = COLOR_BORDER_ACTIVE_FG;
+		borderPixel = colors[COLOR_BORDER_ACTIVE_BG];
+		borderTextPixel = colors[COLOR_BORDER_ACTIVE_FG];
+		pixelUp = colors[COLOR_BORDER_ACTIVE_UP];
+		pixelDown = colors[COLOR_BORDER_ACTIVE_DOWN];
+	} else {
+		borderTextColor = COLOR_BORDER_FG;
+		borderPixel = colors[COLOR_BORDER_BG];
+		borderTextPixel = colors[COLOR_BORDER_FG];
+		pixelUp = colors[COLOR_BORDER_UP];
+		pixelDown = colors[COLOR_BORDER_DOWN];
+	}
+
+	if(np->state.border & BORDER_OUTLINE) {
+		bsize = borderWidth;
+	} else {
+		bsize = 0;
+	}
+
+	canvas = np->parent;
+	gc = borderGC;
+
+	/* Set the window background to reduce perceived flicker on the
+	 * parts of the window that will need to be redrawn. */
+	JXSetWindowBackground(display, canvas, borderPixel);
+
+	JXSetForeground(display, gc, borderPixel);
+	JXFillRectangle(display, canvas, gc, 0, 0, width + 1, height + 1);
+
+	buttonCount = DrawBorderButtons(np, canvas, gc);
+	titleWidth = width - (titleHeight + 2) * buttonCount - bsize
+		- (titleHeight + bsize + 4) - 2;
+
+	if(np->state.border & BORDER_TITLE) {
+
+		if(np->icon && np->width >= titleHeight && drawIcon) {
+			PutIcon(np->icon, canvas, bsize + 2,
+				bsize + titleHeight / 2 - iconSize / 2,
+				iconSize, iconSize);
+		}
+
+		if(np->name && np->name[0] && titleWidth > 0) {
+			RenderString(canvas, FONT_BORDER, borderTextColor,
+				titleHeight + bsize + 4, bsize + titleHeight / 2
+				- GetStringHeight(FONT_BORDER) / 2,
+				titleWidth, borderRegion, np->name);
+		}
+
+	}
+
+	if(np->state.border & BORDER_OUTLINE) {
+
+		/* Draw title outline */
+		JXSetForeground(display, gc, pixelUp);
+		JXDrawLine(display, canvas, gc, borderWidth, borderWidth,
+			width - borderWidth - 1, borderWidth);
+		JXDrawLine(display, canvas, gc, borderWidth, borderWidth + 1,
+			borderWidth, titleHeight + borderWidth - 1);
+
+		JXSetForeground(display, gc, pixelDown);
+		JXDrawLine(display, canvas, gc, borderWidth + 1,
+			titleHeight + borderWidth - 1, width - borderWidth,
+			titleHeight + borderWidth - 1);
+		JXDrawLine(display, canvas, gc, width - borderWidth - 1,
+			borderWidth + 1, width - borderWidth - 1, titleHeight + borderWidth);
+
+		/* Draw outline */
+		JXSetForeground(display, gc, pixelUp);
+		JXDrawLine(display, canvas, gc, width - borderWidth,
+			borderWidth, width - borderWidth, height - borderWidth);
+		JXDrawLine(display, canvas, gc, borderWidth,
+			height - borderWidth, width - borderWidth, height - borderWidth);
+
+		JXSetForeground(display, gc, pixelDown);
+		JXDrawLine(display, canvas, gc, borderWidth - 1,
+			borderWidth - 1, width - borderWidth, borderWidth - 1);
+		JXDrawLine(display, canvas, gc, borderWidth - 1, borderWidth,
+			borderWidth - 1, height - borderWidth);
+
+		JXFillRectangle(display, canvas, gc, width - 2, 0, 2, height);
+		JXFillRectangle(display, canvas, gc, 0, height - 2, width, 2);
+		JXSetForeground(display, gc, pixelUp);
+		JXDrawLine(display, canvas, gc, 0, 0, 0, height - 1);
+		JXDrawLine(display, canvas, gc, 1, 1, 1, height - 2);
+		JXDrawLine(display, canvas, gc, 1, 0, width - 1, 0);
+		JXDrawLine(display, canvas, gc, 1, 1, width - 2, 1);
+
+		if((np->state.border & BORDER_RESIZE)
+			&& !(np->state.status & STAT_SHADED)
+			&& np->width >= 2 * titleHeight * 2
+			&& np->height >= titleHeight * 2) {
+
+			/* Draw marks */
+			JXSetForeground(display, gc, pixelDown);
+
+			/* Upper left */
+			JXDrawLine(display, canvas, gc,
+				titleHeight + borderWidth - 1, 2, titleHeight + borderWidth - 1,
+				borderWidth - 2);
+			JXDrawLine(display, canvas, gc, 2,
+				titleHeight + borderWidth - 1, borderWidth - 2,
+				titleHeight + borderWidth - 1);
+
+			/* Upper right */
+			JXDrawLine(display, canvas, gc,
+				width - titleHeight - borderWidth - 1,
+				2, width - titleHeight - borderWidth - 1, borderWidth - 2);
+			JXDrawLine(display, canvas, gc, width - 3,
+				titleHeight + borderWidth - 1, width - borderWidth + 1,
+				titleHeight + borderWidth - 1);
+
+			/* Lower left */
+			JXDrawLine(display, canvas, gc, 2,
+				height - titleHeight - borderWidth - 1, borderWidth - 2,
+				height - titleHeight - borderWidth - 1);
+			JXDrawLine(display, canvas, gc,
+				titleHeight + borderWidth - 1, height - 3,
+				titleHeight + borderWidth - 1, height - borderWidth + 1);
+
+			/* Lower right */
+			JXDrawLine(display, canvas, gc, width - 3,
+				height - titleHeight - borderWidth - 1, width - borderWidth + 1,
+				height - titleHeight - borderWidth - 1);
+			JXDrawLine(display, canvas, gc,
+				width - titleHeight - borderWidth - 1,
+				height - 3, width - titleHeight - borderWidth - 1,
+				height - borderWidth + 1);
+
+			JXSetForeground(display, gc, pixelUp);
+
+			/* Upper left */
+			JXDrawLine(display, canvas, gc, titleHeight + borderWidth,
+				2, titleHeight + borderWidth, borderWidth - 2);
+			JXDrawLine(display, canvas, gc, 2,
+				titleHeight + borderWidth, borderWidth - 2,
+				titleHeight + borderWidth);
+
+			/* Upper right */
+			JXDrawLine(display, canvas, gc,
+				width - titleHeight - borderWidth, 2,
+				width - titleHeight - borderWidth, borderWidth - 2);
+			JXDrawLine(display, canvas, gc, width - 3,
+				titleHeight + borderWidth, width - borderWidth + 1,
+				titleHeight + borderWidth);
+
+			/* Lower left */
+			JXDrawLine(display, canvas, gc, 2,
+				height - titleHeight - borderWidth,
+				borderWidth - 2, height - titleHeight - borderWidth);
+			JXDrawLine(display, canvas, gc, titleHeight + borderWidth,
+				height - 3, titleHeight + borderWidth, height - borderWidth + 1);
+
+			/* Lower right */
+			JXDrawLine(display, canvas, gc, width - 3,
+				height - titleHeight - borderWidth, width - borderWidth + 1,
+				height - titleHeight - borderWidth);
+			JXDrawLine(display, canvas, gc,
+				width - titleHeight - borderWidth, height - 3,
+				width - titleHeight - borderWidth, height - borderWidth + 1);
+
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DrawButtonBorder(const ClientNode *np, int offset,
+	Pixmap canvas, GC gc) {
+
+	long up, down;
+	long bsize;
+
+	Assert(np);
+
+	if(np->state.status & STAT_ACTIVE) {
+		up = colors[COLOR_BORDER_ACTIVE_UP];
+		down = colors[COLOR_BORDER_ACTIVE_DOWN];
+	} else {
+		up = colors[COLOR_BORDER_UP];
+		down = colors[COLOR_BORDER_DOWN];
+	}
+
+	if(np->state.border & BORDER_OUTLINE) {
+		bsize = borderWidth;
+	} else {
+		bsize = 0;
+	}
+
+	JXSetForeground(display, gc, up);
+	JXDrawLine(display, canvas, gc, offset, bsize + 1,
+		offset, titleHeight + bsize  - 2);
+
+	JXSetForeground(display, gc, down);
+	JXDrawLine(display, canvas, gc, offset - 1,
+		bsize + 1, offset - 1, titleHeight + bsize - 2);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int DrawBorderButtons(const ClientNode *np, Pixmap canvas, GC gc) {
+
+	Pixmap pixmap;
+	int count = 0;
+	int offset;
+	int bsize;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_TITLE)) {
+		return count;
+	}
+	if(np->state.border & BORDER_OUTLINE) {
+		bsize = borderWidth;
+	} else {
+		bsize = 0;
+	}
+
+	offset = np->width + bsize - titleHeight;
+
+	if(offset <= bsize + titleHeight) {
+		return count;
+	}
+
+	if(np->state.border & BORDER_CLOSE) {
+
+		DrawButtonBorder(np, offset, canvas, gc);
+
+		if(np->state.status & STAT_ACTIVE) {
+			pixmap = pixmaps[BP_ACTIVE_CLOSE];
+		} else {
+			pixmap = pixmaps[BP_CLOSE];
+		}
+
+		JXCopyArea(display, pixmap, canvas, gc, 0, 0, 16, 16,
+			offset + titleHeight / 2 - 8, bsize + titleHeight / 2 - 8);
+
+		offset -= titleHeight;
+		++count;
+
+		if(offset <= bsize + titleHeight) {
+			return count;
+		}
+
+	}
+
+	if(np->state.border & BORDER_MAX) {
+
+		if(np->state.status & STAT_MAXIMIZED) {
+			if(np->state.status & STAT_ACTIVE) {
+				pixmap = pixmaps[BP_ACTIVE_MAXIMIZE_ACTIVE];
+			} else {
+				pixmap = pixmaps[BP_MAXIMIZE_ACTIVE];
+			}
+		} else {
+			if(np->state.status & STAT_ACTIVE) {
+				pixmap = pixmaps[BP_ACTIVE_MAXIMIZE];
+			} else {
+				pixmap = pixmaps[BP_MAXIMIZE];
+			}
+		}
+		JXCopyArea(display, pixmap, canvas, gc, 0, 0, 16, 16,
+			offset + titleHeight / 2 - 8, bsize + titleHeight / 2 - 8);
+
+		DrawButtonBorder(np, offset, canvas, gc);
+
+		offset -= titleHeight;
+		++count;
+
+		if(offset <= bsize + titleHeight) {
+			return count;
+		}
+
+	}
+
+	if(np->state.border & BORDER_MIN) {
+
+		DrawButtonBorder(np, offset, canvas, gc);
+
+		if(np->state.status & STAT_ACTIVE) {
+			pixmap = pixmaps[BP_ACTIVE_MINIMIZE];
+		} else {
+			pixmap = pixmaps[BP_MINIMIZE];
+		}
+
+		JXCopyArea(display, pixmap, canvas, gc, 0, 0, 16, 16,
+			offset + titleHeight / 2 - 8, bsize + titleHeight / 2 - 8);
+
+		++count;
+
+	}
+
+	return count;
+
+}
+
+/****************************************************************************
+ * Redraw the borders on the current desktop.
+ * This should be done after loading clients since the stacking order
+ * may cause borders on the current desktop to become visible after moving
+ * clients to their assigned desktops.
+ ****************************************************************************/
+void ExposeCurrentDesktop() {
+
+	ClientNode *np;
+	int layer;
+
+	for(layer = 0; layer < LAYER_COUNT; layer++) {
+		for(np = nodes[layer]; np; np = np->next) {
+			if(!(np->state.status & (STAT_HIDDEN | STAT_MINIMIZED))) {
+				DrawBorder(np, NULL);
+			}
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void GetBorderSize(const ClientNode *np,
+	int *north, int *south, int *east, int *west) {
+
+	Assert(np);
+	Assert(north);
+	Assert(south);
+	Assert(east);
+	Assert(west);
+
+	/* Full screen is a special case. */
+	if(np->state.status & STAT_FULLSCREEN) {
+		*north = 0;
+		*south = 0;
+		*east = 0;
+		*west = 0;
+		return;
+	}
+
+	if(np->state.border & BORDER_OUTLINE) {
+
+		*north = borderWidth;
+		*south = borderWidth;
+		*east = borderWidth;
+		*west = borderWidth;
+
+	} else {
+
+		*north = 0;
+		*south = 0;
+		*east = 0;
+		*west = 0;
+
+	}
+
+	if(np->state.border & BORDER_TITLE) {
+		*north += titleHeight;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetBorderWidth(const char *str) {
+
+	int width;
+
+	if(str) {
+
+		width = atoi(str);
+		if(width < MIN_BORDER_WIDTH || width > MAX_BORDER_WIDTH) {
+			borderWidth = DEFAULT_BORDER_WIDTH;
+			Warning("invalid border width specified: %d", width);
+		} else {
+			borderWidth = width;
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetTitleHeight(const char *str) {
+
+	int height;
+
+	if(str) {
+
+		height = atoi(str);
+		if(height < MIN_TITLE_HEIGHT || height > MAX_TITLE_HEIGHT) {
+			titleHeight = DEFAULT_TITLE_HEIGHT;
+			Warning("invalid title height specified: %d", height);
+		} else {
+			titleHeight = height;
+		}
+
+	}
+
+}
+
+
diff --git a/src/border.h b/src/border.h
new file mode 100644
index 0000000..55458db
--- /dev/null
+++ b/src/border.h
@@ -0,0 +1,80 @@
+/**
+ * @file border.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header file for border functions.
+ *
+ */
+
+#ifndef BORDER_H
+#define BORDER_H
+
+struct ClientNode;
+
+/** Flags to determine what action to take on the border. */
+typedef enum {
+	BA_NONE      = 0,      /**< Do nothing. */
+	BA_RESIZE    = 1,      /**< Resize the window. */
+	BA_MOVE      = 2,      /**< Move the window. */
+	BA_CLOSE     = 3,      /**< Close the window. */
+	BA_MAXIMIZE  = 4,      /**< Maximize the window. */
+	BA_MINIMIZE  = 5,      /**< Minimize the window. */
+	BA_MENU      = 6,      /**< Show the window menu. */
+	BA_RESIZE_N  = 0x10,   /**< Resize north. */
+	BA_RESIZE_S  = 0x20,   /**< Resize south. */
+	BA_RESIZE_E  = 0x40,   /**< Resize east. */
+	BA_RESIZE_W  = 0x80    /**< Resize west. */
+} BorderActionType;
+
+/*@{*/
+void InitializeBorders();
+void StartupBorders();
+void ShutdownBorders();
+void DestroyBorders();
+/*@}*/
+
+/** Determine the action to take for a client.
+ * @param np The client.
+ * @param x The x-coordinate of the mouse (frame relative).
+ * @param y The y-coordinate of the mouse (frame relative).
+ * @return The action to take.
+ */
+BorderActionType GetBorderActionType(const struct ClientNode *np, int x, int y);
+
+/** Draw a window border.
+ * @param np The client whose frame to draw.
+ * @param expose The expose event causing the redraw (or NULL).
+ */
+void DrawBorder(const struct ClientNode *np, const XExposeEvent *expose);
+
+/** Get the size of a border icon.
+ * @return The size in pixels (note that icons are square).
+ */
+int GetBorderIconSize();
+
+/** Get the size of a window border.
+ * @param np The client.
+ * @param north Pointer to the value to contain the north border size.
+ * @param south Pointer to the value to contain the south border size.
+ * @param east Pointer to the value to contain the east border size.
+ * @param west Pointer to the value to contain the west border size.
+ */
+void GetBorderSize(const struct ClientNode *np,
+	int *north, int *south, int *east, int *west);
+
+/** Set the size of window borders.
+ * @param str The size to use in string form.
+ */
+void SetBorderWidth(const char *str);
+
+/** Set the size of window title bars.
+ * @param str The size to use in string form.
+ */
+void SetTitleHeight(const char *str);
+
+/** Redraw all borders on the current desktop. */
+void ExposeCurrentDesktop();
+
+#endif
+
diff --git a/src/button.c b/src/button.c
new file mode 100644
index 0000000..0d62742
--- /dev/null
+++ b/src/button.c
@@ -0,0 +1,212 @@
+/***************************************************************************
+ * Functions to handle drawing buttons.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "button.h"
+#include "font.h"
+#include "color.h"
+#include "main.h"
+#include "icon.h"
+#include "image.h"
+
+static void GetScaledIconSize(IconNode *ip, int maxsize,
+	int *width, int *height);
+
+/***************************************************************************
+ ***************************************************************************/
+void DrawButton(ButtonNode *bp) {
+
+	long outlinePixel;
+	long topPixel, bottomPixel;
+	ColorType fg, bg;
+
+	Drawable drawable;
+	GC gc;
+	int x, y;
+	int width, height;
+	int xoffset, yoffset;
+
+	int iconWidth, iconHeight;
+	int textWidth, textHeight;
+
+	Assert(bp);
+
+	drawable = bp->drawable;
+	gc = bp->gc;
+	x = bp->x;
+	y = bp->y;
+	width = bp->width;
+	height = bp->height;
+
+	switch(bp->type) {
+	case BUTTON_LABEL:
+		fg = COLOR_MENU_FG;
+		bg = COLOR_MENU_BG;
+		outlinePixel = colors[COLOR_MENU_BG];
+		topPixel = colors[COLOR_MENU_BG];
+		bottomPixel = colors[COLOR_MENU_BG];
+		break;
+	case BUTTON_MENU_ACTIVE:
+		fg = COLOR_MENU_ACTIVE_FG;
+		bg = COLOR_MENU_ACTIVE_BG;
+		outlinePixel = colors[COLOR_MENU_ACTIVE_DOWN];
+		topPixel = colors[COLOR_MENU_ACTIVE_UP];
+		bottomPixel = colors[COLOR_MENU_ACTIVE_DOWN];
+		break;
+	case BUTTON_TASK:
+		fg = COLOR_TASK_FG;
+		bg = COLOR_TASK_BG;
+		outlinePixel = colors[COLOR_TASK_DOWN];
+		topPixel = colors[COLOR_TASK_UP];
+		bottomPixel = colors[COLOR_TASK_DOWN];
+		break;
+	case BUTTON_TASK_ACTIVE:
+		fg = COLOR_TASK_ACTIVE_FG;
+		bg = COLOR_TASK_ACTIVE_BG;
+		outlinePixel = colors[COLOR_TASK_ACTIVE_DOWN];
+		topPixel = colors[COLOR_TASK_ACTIVE_DOWN];
+		bottomPixel = colors[COLOR_TASK_ACTIVE_UP];
+		break;
+	case BUTTON_MENU:
+	default:
+		fg = COLOR_MENU_FG;
+		bg = COLOR_MENU_BG;
+		outlinePixel = colors[COLOR_MENU_DOWN];
+		topPixel = colors[COLOR_MENU_UP];
+		bottomPixel = colors[COLOR_MENU_DOWN];
+		break;
+	}
+
+	JXSetForeground(display, gc, colors[bg]);
+	JXFillRectangle(display, drawable, gc, x + 2, y + 2, width - 3, height - 3);
+
+	JXSetForeground(display, gc, outlinePixel);
+	JXDrawLine(display, drawable, gc, x + 1, y, x + width - 1, y);
+	JXDrawLine(display, drawable, gc, x + 1, y + height, x + width - 1,
+		y + height);
+	JXDrawLine(display, drawable, gc, x, y + 1, x, y + height - 1);
+	JXDrawLine(display, drawable, gc, x + width, y + 1, x + width,
+		y + height - 1);
+
+	JXSetForeground(display, gc, topPixel);
+	JXDrawLine(display, drawable, gc, x + 1, y + 1, x + width - 2, y + 1);
+	JXDrawLine(display, drawable, gc, x + 1, y + 2, x + 1, y + height - 2);
+
+	JXSetForeground(display, gc, bottomPixel);
+	JXDrawLine(display, drawable, gc, x + 1, y + height - 1, x + width - 1,
+		y + height - 1);
+	JXDrawLine(display, drawable, gc, x + width - 1, y + 1, x + width - 1,
+		y + height - 2);
+
+	iconWidth = 0;
+	iconHeight = 0;
+	if(bp->icon) {
+
+		if(width < height) {
+			GetScaledIconSize(bp->icon, width - 4, &iconWidth, &iconHeight);
+		} else {
+			GetScaledIconSize(bp->icon, height - 4, &iconWidth, &iconHeight);
+		}
+
+	}
+
+	textWidth = 0;
+	textHeight = 0;
+	if(bp->text) {
+		textWidth = GetStringWidth(bp->font, bp->text);
+		textHeight = GetStringHeight(bp->font);
+		if(textWidth + iconWidth + 10 > width) {
+			textWidth = width - iconWidth - 10;
+			if(textWidth < 0) {
+				textWidth = 0;
+			}
+		}
+	}
+
+	switch(bp->alignment) {
+	case ALIGN_RIGHT:
+		xoffset = width - iconWidth - textWidth + 4;
+		if(xoffset < 4) {
+			xoffset = 4;
+		}
+		break;
+	case ALIGN_CENTER:
+		xoffset = width / 2 - (iconWidth + textWidth) / 2;
+		if(xoffset < 0) {
+			xoffset = 0;
+		}
+		break;
+	case ALIGN_LEFT:
+	default:
+		xoffset = 4;
+		break;
+	}
+
+	if(bp->icon) {
+		yoffset = height / 2 - iconHeight / 2;
+		PutIcon(bp->icon, drawable, x + xoffset, y + yoffset,
+			iconWidth, iconHeight);
+		xoffset += iconWidth + 2;
+	}
+
+	if(bp->text) {
+		yoffset = height / 2 - textHeight / 2;
+		RenderString(drawable, bp->font, fg, x + xoffset, y + yoffset,
+			textWidth, NULL, bp->text);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ResetButton(ButtonNode *bp, Drawable d, GC g) {
+
+	Assert(bp);
+
+	bp->type = BUTTON_MENU;
+	bp->drawable = d;
+	bp->gc = g;
+	bp->font = FONT_TRAY;
+	bp->alignment = ALIGN_LEFT;
+	bp->x = 0;
+	bp->y = 0;
+	bp->width = 1;
+	bp->height = 1;
+	bp->icon = NULL;
+	bp->text = NULL;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void GetScaledIconSize(IconNode *ip, int maxsize,
+	int *width, int *height) {
+
+	double ratio;
+
+	Assert(ip);
+	Assert(width);
+	Assert(height);
+
+	/* width to height */
+	Assert(ip->image->height > 0);
+	ratio = (double)ip->image->width / ip->image->height;
+
+	if(ip->image->width > ip->image->height) {
+
+		/* Compute size wrt width */
+		*width = maxsize * ratio;
+		*height = *width / ratio;
+
+	} else {
+
+		/* Compute size wrt height */
+		*height = maxsize / ratio;
+		*width = *height * ratio;
+
+	}
+
+}
+
diff --git a/src/button.h b/src/button.h
new file mode 100644
index 0000000..9303ea5
--- /dev/null
+++ b/src/button.h
@@ -0,0 +1,63 @@
+/**
+ * @file button.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header file for button functions.
+ *
+ */
+
+#ifndef BUTTON_H
+#define BUTTON_H
+
+#include "font.h"
+
+struct IconNode;
+
+/** Button types. */
+typedef enum {
+	BUTTON_LABEL,        /**< Label. */
+	BUTTON_MENU,         /**< Menu item. */
+	BUTTON_MENU_ACTIVE,  /**< Active menu item. */
+	BUTTON_TASK,         /**< Item in the task list. */
+	BUTTON_TASK_ACTIVE   /**< Active item in the task list. */
+} ButtonType;
+
+/** Alignment of content in a button. */
+typedef enum {
+	ALIGN_LEFT,   /**< Left align. */
+	ALIGN_CENTER, /**< Center align. */
+	ALIGN_RIGHT   /**< Right align. */
+} AlignmentType;
+
+/** Data used for drawing a button. */
+typedef struct {
+
+	ButtonType type;         /**< The type of button to draw. */
+	Drawable drawable;       /**< The place to put the button. */
+	GC gc;                   /**< Graphics context used for drawing. */
+	FontType font;           /**< The font for button text. */
+	AlignmentType alignment; /**< Alignment of the button content. */
+
+	int x, y;           /**< The coordinates to render the button. */
+	int width, height;  /**< The size of the button. */
+
+	struct IconNode *icon;  /**< Icon used in the button. */
+	const char *text;       /**< Text used in the button. */
+
+} ButtonNode;
+
+/** Draw a button.
+ * @param bp The button to draw.
+ */
+void DrawButton(ButtonNode *bp);
+
+/** Reset the contents of a ButtonNode structure.
+ * @param bp The structure to reset.
+ * @param d The drawable to use.
+ * @param g The graphics context to use.
+ */
+void ResetButton(ButtonNode *bp, Drawable d, GC g);
+
+#endif
+
diff --git a/src/client.c b/src/client.c
new file mode 100644
index 0000000..6c1976e
--- /dev/null
+++ b/src/client.c
@@ -0,0 +1,1423 @@
+/**
+ * @file client.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Functions to handle client windows.
+ *
+ */
+
+#include "jwm.h"
+#include "client.h"
+#include "main.h"
+#include "icon.h"
+#include "hint.h"
+#include "group.h"
+#include "tray.h"
+#include "confirm.h"
+#include "key.h"
+#include "cursor.h"
+#include "taskbar.h"
+#include "screen.h"
+#include "pager.h"
+#include "color.h"
+#include "error.h"
+#include "place.h"
+
+static const int STACK_BLOCK_SIZE = 8;
+
+ClientNode *nodes[LAYER_COUNT];
+ClientNode *nodeTail[LAYER_COUNT];
+
+static ClientNode *activeClient;
+
+static int clientCount;
+
+static void LoadFocus();
+static void ReparentClient(ClientNode *np, int notOwner);
+ 
+static void MinimizeTransients(ClientNode *np);
+static void CheckShape(ClientNode *np);
+
+static void RestoreTransients(ClientNode *np, int raise);
+
+static void KillClientHandler(ClientNode *np);
+
+/** Initialize client data. */
+void InitializeClients() {
+}
+
+/** Load windows that are already mapped. */
+void StartupClients() {
+
+	XWindowAttributes attr;
+	Window rootReturn, parentReturn, *childrenReturn;
+	unsigned int childrenCount;
+	unsigned int x;
+
+	clientCount = 0;
+	activeClient = NULL;
+	currentDesktop = 0;
+
+	/* Clear out the client lists. */
+	for(x = 0; x < LAYER_COUNT; x++) {
+		nodes[x] = NULL;
+		nodeTail[x] = NULL;
+	}
+
+	/* Query client windows. */
+	JXQueryTree(display, rootWindow, &rootReturn, &parentReturn,
+		&childrenReturn, &childrenCount);
+
+	/* Add each client. */
+	for(x = 0; x < childrenCount; x++) {
+		if(JXGetWindowAttributes(display, childrenReturn[x], &attr)) {
+			if(attr.override_redirect == False
+				&& attr.map_state == IsViewable) {
+				AddClientWindow(childrenReturn[x], 1, 1);
+			}
+		}
+	}
+
+	JXFree(childrenReturn);
+
+	LoadFocus();
+
+	UpdateTaskBar();
+	UpdatePager();
+
+}
+
+/** Release client windows. */
+void ShutdownClients() {
+
+	int x;
+
+	for(x = 0; x < LAYER_COUNT; x++) {
+		while(nodeTail[x]) {
+			RemoveClient(nodeTail[x]);
+		}
+	}
+
+}
+
+/** Destroy client data. */
+void DestroyClients() {
+}
+
+/** Set the focus to the window currently under the mouse pointer. */
+void LoadFocus() {
+
+	ClientNode *np;
+	Window rootReturn, childReturn;
+	int rootx, rooty;
+	int winx, winy;
+	unsigned int mask;
+
+	JXQueryPointer(display, rootWindow, &rootReturn, &childReturn,
+		&rootx, &rooty, &winx, &winy, &mask);
+
+	np = FindClientByWindow(childReturn);
+	if(np) {
+		FocusClient(np);
+	}
+
+}
+
+/** Add a window to management. */
+ClientNode *AddClientWindow(Window w, int alreadyMapped, int notOwner) {
+
+	XWindowAttributes attr;
+	ClientNode *np;
+
+	Assert(w != None);
+
+	/* Get window attributes. */
+	if(JXGetWindowAttributes(display, w, &attr) == 0) {
+		return NULL;
+	}
+
+	/* Determine if we should care about this window. */
+	if(attr.override_redirect == True) {
+		return NULL;
+	}
+	if(attr.class == InputOnly) {
+		return NULL;
+	}
+
+	/* Prepare a client node for this window. */
+	np = Allocate(sizeof(ClientNode));
+	memset(np, 0, sizeof(ClientNode));
+
+	np->window = w;
+	np->owner = None;
+	np->state.desktop = currentDesktop;
+	np->controller = NULL;
+	np->name = NULL;
+	np->colormaps = NULL;
+
+	np->x = attr.x;
+	np->y = attr.y;
+	np->width = attr.width;
+	np->height = attr.height;
+	np->cmap = attr.colormap;
+	np->colormaps = NULL;
+	np->state.status = STAT_NONE;
+	np->state.layer = LAYER_NORMAL;
+
+	np->state.border = BORDER_DEFAULT;
+	np->borderAction = BA_NONE;
+
+	ReadClientProtocols(np);
+
+	if(!notOwner) {
+		np->state.border = BORDER_OUTLINE | BORDER_TITLE | BORDER_MOVE;
+		np->state.status |= STAT_WMDIALOG | STAT_STICKY;
+	}
+
+	/* We now know the layer, so insert */
+	np->prev = NULL;
+	np->next = nodes[np->state.layer];
+	if(np->next) {
+		np->next->prev = np;
+	} else {
+		nodeTail[np->state.layer] = np;
+	}
+	nodes[np->state.layer] = np;
+
+	LoadIcon(np);
+
+	ApplyGroups(np);
+
+	SetDefaultCursor(np->window);
+	ReparentClient(np, notOwner);
+	PlaceClient(np, alreadyMapped);
+
+	/* If one of these fails we are SOL, so who cares. */
+	XSaveContext(display, np->window, clientContext, (void*)np);
+	XSaveContext(display, np->parent, frameContext, (void*)np);
+
+	if(np->state.status & STAT_MAPPED) {
+		JXMapWindow(display, np->window);
+		JXMapWindow(display, np->parent);
+	}
+
+	DrawBorder(np, NULL);
+
+	AddClientToTaskBar(np);
+
+	if(!alreadyMapped) {
+		RaiseClient(np);
+	}
+
+	++clientCount;
+
+	if(np->state.status & STAT_STICKY) {
+		SetCardinalAtom(np->window, ATOM_NET_WM_DESKTOP, ~0UL);
+	} else {
+		SetCardinalAtom(np->window, ATOM_NET_WM_DESKTOP, np->state.desktop);
+	}
+
+	/* Shade the client if requested. */
+	if(np->state.status & STAT_SHADED) {
+		ShadeClient(np);
+	}
+
+	/* Minimize the client if requested. */
+	if(np->state.status & STAT_MINIMIZED) {
+		np->state.status &= ~STAT_MINIMIZED;
+		MinimizeClient(np);
+	}
+
+	/* Maximize the client if requested. */
+	if(np->state.status & STAT_MAXIMIZED) {
+		np->state.status &= ~STAT_MAXIMIZED;
+		MaximizeClient(np);
+	}
+
+	/* Make sure we're still in sync */
+	WriteState(np);
+	SendConfigureEvent(np);
+
+	/* Hide the client if we're not on the right desktop. */
+	if(np->state.desktop != currentDesktop
+		&& !(np->state.status & STAT_STICKY)) {
+		HideClient(np);
+	}
+
+	ReadClientStrut(np);
+
+	/* Focus transients if their parent has focus. */
+	if(np->owner != None) {
+
+		if(activeClient && np->owner == activeClient->window) {
+			FocusClient(np);
+		}
+
+	}
+
+	return np;
+
+}
+
+/** Minimize a client window and all of its transients. */
+void MinimizeClient(ClientNode *np) {
+
+	Assert(np);
+
+	if(focusModel == FOCUS_CLICK && np == activeClient) {
+		FocusNextStacked(np);
+	}
+
+	MinimizeTransients(np);
+
+	UpdateTaskBar();
+	UpdatePager();
+
+}
+
+/** Minimize all transients as well as the specified client. */
+void MinimizeTransients(ClientNode *np) {
+
+	ClientNode *tp;
+	int x;
+
+	Assert(np);
+
+	/* A minimized client can't be active. */
+	if(activeClient == np) {
+		activeClient = NULL;
+		np->state.status &= ~STAT_ACTIVE;
+	}
+
+	/* Unmap the window and update its state. */
+	if(np->state.status & (STAT_MAPPED | STAT_SHADED)) {
+		JXUnmapWindow(display, np->window);
+		JXUnmapWindow(display, np->parent);
+	}
+	np->state.status |= STAT_MINIMIZED;
+	np->state.status &= ~STAT_MAPPED;
+	WriteState(np);
+
+	/* Minimize transient windows. */
+	for(x = 0; x < LAYER_COUNT; x++) {
+		for(tp = nodes[x]; tp; tp = tp->next) {
+			if(tp->owner == np->window
+				&& (tp->state.status & (STAT_MAPPED | STAT_SHADED))
+				&& !(tp->state.status & STAT_MINIMIZED)) {
+				MinimizeTransients(tp);
+			}
+		}
+	}
+
+}
+
+/** Shade a client. */
+void ShadeClient(ClientNode *np) {
+
+	int north, south, east, west;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_TITLE)) {
+		return;
+	}
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	if(np->state.status & STAT_MAPPED) {
+		JXUnmapWindow(display, np->window);
+	}
+	np->state.status |= STAT_SHADED;
+	np->state.status &= ~STAT_MINIMIZED;
+	np->state.status &= ~STAT_SDESKTOP;
+	np->state.status &= ~STAT_MAPPED;
+
+	JXResizeWindow(display, np->parent, np->width + east + west,
+		north + south);
+
+	WriteState(np);
+
+#ifdef USE_SHAPE
+	if(np->state.status & STAT_SHAPE) {
+		SetShape(np);
+	}
+#endif
+
+}
+
+/** Unshade a client. */
+void UnshadeClient(ClientNode *np) {
+
+	int bsize;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_TITLE)) {
+		return;
+	}
+	if(np->state.border & BORDER_OUTLINE) {
+		bsize = borderWidth;
+	} else {
+		bsize = 0;
+	}
+
+	if(np->state.status & STAT_SHADED) {
+		JXMapWindow(display, np->window);
+		np->state.status |= STAT_MAPPED;
+		np->state.status &= ~STAT_SHADED;
+	}
+
+	JXResizeWindow(display, np->parent, np->width + 2 * bsize,
+		np->height + titleHeight + 2 * bsize);
+
+	WriteState(np);
+
+#ifdef USE_SHAPE
+	if(np->state.status & STAT_SHAPE) {
+		SetShape(np);
+	}
+#endif
+
+	RefocusClient();
+	RestackClients();
+
+}
+
+/** Set a client's state to withdrawn. */
+void SetClientWithdrawn(ClientNode *np) {
+
+	Assert(np);
+
+	if(activeClient == np) {
+		activeClient = NULL;
+		np->state.status &= ~STAT_ACTIVE;
+		FocusNextStacked(np);
+	}
+
+	if(np->state.status & STAT_MAPPED) {
+		JXUnmapWindow(display, np->window);
+		JXUnmapWindow(display, np->parent);
+		WriteState(np);
+	} else if(np->state.status & STAT_SHADED) {
+		JXUnmapWindow(display, np->parent);
+		WriteState(np);
+	}
+
+	np->state.status &= ~STAT_SHADED;
+	np->state.status &= ~STAT_MAPPED;
+	np->state.status &= ~STAT_MINIMIZED;
+	np->state.status &= ~STAT_SDESKTOP;
+
+	UpdateTaskBar();
+	UpdatePager();
+
+}
+
+/** Restore a window with its transients (helper method). */
+void RestoreTransients(ClientNode *np, int raise) {
+
+	ClientNode *tp;
+	int x;
+
+	Assert(np);
+
+	/* Restore this window. */
+	if(!(np->state.status & STAT_MAPPED)) {
+		if(np->state.status & STAT_SHADED) {
+			JXMapWindow(display, np->parent);
+		} else {
+			JXMapWindow(display, np->window);
+			JXMapWindow(display, np->parent);
+			np->state.status |= STAT_MAPPED;
+		}
+	}
+	np->state.status &= ~STAT_MINIMIZED;
+	np->state.status &= ~STAT_SDESKTOP;
+
+	WriteState(np);
+
+	/* Restore transient windows. */
+	for(x = 0; x < LAYER_COUNT; x++) {
+		for(tp = nodes[x]; tp; tp = tp->next) {
+			if(tp->owner == np->window
+				&& !(tp->state.status & (STAT_MAPPED | STAT_SHADED))
+				&& (tp->state.status & STAT_MINIMIZED)) {
+				RestoreTransients(tp, raise);
+			}
+		}
+	}
+
+	if(raise) {
+		RaiseClient(np);
+	}
+
+}
+
+/** Restore a client window and its transients. */
+void RestoreClient(ClientNode *np, int raise) {
+
+	Assert(np);
+
+	RestoreTransients(np, raise);
+
+	RestackClients();
+	UpdateTaskBar();
+	UpdatePager();
+
+}
+
+/** Set the client layer. This will affect transients. */
+void SetClientLayer(ClientNode *np, unsigned int layer) {
+
+	ClientNode *tp, *next;
+	int x;
+
+	Assert(np);
+
+	if(layer > LAYER_TOP) {
+		Warning("Client %s requested an invalid layer: %d", np->name, layer);
+		return;
+	}
+
+	if(np->state.layer != layer) {
+
+		/* Loop through all clients so we get transients. */
+		for(x = 0; x < LAYER_COUNT; x++) {
+			tp = nodes[x];
+			while(tp) {
+				if(tp == np || tp->owner == np->window) {
+
+					next = tp->next;
+
+					/* Remove from the old node list */
+					if(next) {
+						next->prev = tp->prev;
+					} else {
+						nodeTail[tp->state.layer] = tp->prev;
+					}
+					if(tp->prev) {
+						tp->prev->next = next;
+					} else {
+						nodes[tp->state.layer] = next;
+					}
+
+					/* Insert into the new node list */
+					tp->prev = NULL;
+					tp->next = nodes[layer];
+					if(nodes[layer]) {
+						nodes[layer]->prev = tp;
+					} else {
+						nodeTail[layer] = tp;
+					}
+					nodes[layer] = tp;
+
+					/* Set the new layer */
+					tp->state.layer = layer;
+					SetCardinalAtom(tp->window, ATOM_WIN_LAYER, layer);
+
+					/* Make sure we continue on the correct layer list. */
+					tp = next;
+
+				} else {
+					tp = tp->next;
+				}
+			}
+		}
+
+		RestackClients();
+
+	}
+
+}
+
+/** Set a client's sticky status. This will update transients. */
+void SetClientSticky(ClientNode *np, int isSticky) {
+
+	ClientNode *tp;
+	int old;
+	int x;
+
+	Assert(np);
+
+	/* Get the old sticky status. */
+	if(np->state.status & STAT_STICKY) {
+		old = 1;
+	} else {
+		old = 0;
+	}
+
+	if(isSticky && !old) {
+
+		/* Change from non-sticky to sticky. */
+
+		for(x = 0; x < LAYER_COUNT; x++) {
+			for(tp = nodes[x]; tp; tp = tp->next) {
+				if(tp == np || tp->owner == np->window) {
+					tp->state.status |= STAT_STICKY;
+					SetCardinalAtom(tp->window, ATOM_NET_WM_DESKTOP, ~0UL);
+					WriteState(tp);
+				}
+			}
+		}
+
+	} else if(!isSticky && old) {
+
+		/* Change from sticky to non-sticky. */
+
+		for(x = 0; x < LAYER_COUNT; x++) {
+			for(tp = nodes[x]; tp; tp = tp->next) {
+				if(tp == np || tp->owner == np->window) {
+					tp->state.status &= ~STAT_STICKY;
+					WriteState(tp);
+				}
+			}
+		}
+
+		/* Since this client is no longer sticky, we need to assign
+		 * a desktop. Here we use the current desktop.
+		 * Note that SetClientDesktop updates transients (which is good).
+		 */
+		SetClientDesktop(np, currentDesktop);
+
+	}
+
+}
+
+/** Set a client's desktop. This will update transients. */
+void SetClientDesktop(ClientNode *np, unsigned int desktop) {
+
+	ClientNode *tp;
+	int x;
+
+	Assert(np);
+
+	if(desktop >= desktopCount) {
+		return;
+	}
+
+	if(!(np->state.status & STAT_STICKY)) {
+		for(x = 0; x < LAYER_COUNT; x++) {
+			for(tp = nodes[x]; tp; tp = tp->next) {
+				if(tp == np || tp->owner == np->window) {
+
+					tp->state.desktop = desktop;
+
+					if(desktop == currentDesktop) {
+						ShowClient(tp);
+					} else {
+						HideClient(tp);
+					}
+
+					SetCardinalAtom(tp->window, ATOM_NET_WM_DESKTOP,
+						tp->state.desktop);
+				}
+			}
+		}
+		UpdatePager();
+		UpdateTaskBar();
+	}
+
+}
+
+/** Hide a client without unmapping. This will NOT update transients. */
+void HideClient(ClientNode *np) {
+
+	Assert(np);
+
+	if(activeClient == np) {
+		activeClient = NULL;
+	}
+	np->state.status |= STAT_HIDDEN;
+	if(np->state.status & (STAT_MAPPED | STAT_SHADED)) {
+		JXUnmapWindow(display, np->parent);
+	}
+
+}
+
+/** Show a hidden client. This will NOT update transients. */
+void ShowClient(ClientNode *np) {
+
+	Assert(np);
+
+	if(np->state.status & STAT_HIDDEN) {
+		np->state.status &= ~STAT_HIDDEN;
+		if(np->state.status & (STAT_MAPPED | STAT_SHADED)) {
+			JXMapWindow(display, np->parent);
+			if(np->state.status & STAT_ACTIVE) {
+				FocusClient(np);
+			}
+		}
+	}
+
+}
+
+/** Maximize a client window. */
+void MaximizeClient(ClientNode *np) {
+
+	int north, south, east, west;
+
+	Assert(np);
+
+	/* We don't want to mess with full screen clients. */
+	if(np->state.status & STAT_FULLSCREEN) {
+		SetClientFullScreen(np, 0);
+	}
+
+	if(np->state.status & STAT_SHADED) {
+		UnshadeClient(np);
+	}
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	if(np->state.status & STAT_MAXIMIZED) {
+		np->x = np->oldx;
+		np->y = np->oldy;
+		np->width = np->oldWidth;
+		np->height = np->oldHeight;
+		np->state.status &= ~STAT_MAXIMIZED;
+	} else {
+		PlaceMaximizedClient(np);
+	}
+
+	JXMoveResizeWindow(display, np->parent,
+		np->x - west, np->y - north,
+		np->width + east + west,
+		np->height + north + south);
+	JXMoveResizeWindow(display, np->window, west,
+		north, np->width, np->height);
+
+	WriteState(np);
+	SendConfigureEvent(np);
+
+}
+
+/** Set a client's full screen state. */
+void SetClientFullScreen(ClientNode *np, int fullScreen) {
+
+	XEvent event;
+	int north, south, east, west;
+	const ScreenType *sp;
+
+	Assert(np);
+
+	/* Make sure there's something to do. */
+	if(fullScreen && (np->state.status & STAT_FULLSCREEN)) {
+		return;
+	} else if (!fullScreen && !(np->state.status & STAT_FULLSCREEN)) {
+		return;
+	}
+
+	if(np->state.status & STAT_SHADED) {
+		UnshadeClient(np);
+	}
+
+	if(fullScreen) {
+
+		np->state.status |= STAT_FULLSCREEN;
+
+		sp = GetCurrentScreen(np->x, np->y);
+
+		JXReparentWindow(display, np->window, rootWindow, 0, 0);
+		JXMoveResizeWindow(display, np->window, 0, 0,
+			sp->width, sp->height);
+
+		SetClientLayer(np, LAYER_TOP);
+
+	} else {
+
+		np->state.status &= ~STAT_FULLSCREEN;
+
+		GetBorderSize(np, &north, &south, &east, &west);
+
+		JXReparentWindow(display, np->window, np->parent, west, north);
+		JXMoveResizeWindow(display, np->window, west,
+			north, np->width, np->height);
+
+		event.type = MapRequest;
+		event.xmaprequest.send_event = True;
+		event.xmaprequest.display = display;
+		event.xmaprequest.parent = np->parent;
+		event.xmaprequest.window = np->window;
+		JXSendEvent(display, rootWindow, False,
+			SubstructureRedirectMask, &event);
+
+		SetClientLayer(np, LAYER_NORMAL);
+
+	}
+
+	WriteState(np);
+	SendConfigureEvent(np);
+
+}
+
+/** Set the active client. */
+void FocusClient(ClientNode *np) {
+
+	Assert(np);
+
+	if(!(np->state.status & (STAT_MAPPED | STAT_SHADED))) {
+		return;
+	}
+	if(np->state.status & STAT_HIDDEN) {
+		return;
+	}
+
+	if(activeClient != np) {
+		if(activeClient) {
+			activeClient->state.status &= ~STAT_ACTIVE;
+			DrawBorder(activeClient, NULL);
+		}
+		np->state.status |= STAT_ACTIVE;
+		activeClient = np;
+
+		if(!(np->state.status & STAT_SHADED)) {
+			UpdateClientColormap(np);
+			SetWindowAtom(rootWindow, ATOM_NET_ACTIVE_WINDOW, np->window);
+		}
+
+		DrawBorder(np, NULL);
+		UpdatePager();
+		UpdateTaskBar();
+
+	}
+
+	if(np->state.status & STAT_MAPPED && !(np->state.status & STAT_HIDDEN)) {
+		JXSetInputFocus(display, np->window, RevertToPointerRoot, CurrentTime);
+	} else {
+		JXSetInputFocus(display, rootWindow, RevertToPointerRoot, CurrentTime);
+	}
+
+}
+
+/** Focus the next client in the stacking order. */
+void FocusNextStacked(ClientNode *np) {
+
+	int x;
+	ClientNode *tp;
+
+	Assert(np);
+
+	for(tp = np->next; tp; tp = tp->next) {
+		if((tp->state.status & (STAT_MAPPED | STAT_SHADED))
+			&& !(tp->state.status & STAT_HIDDEN)) {
+			FocusClient(tp);
+			return;
+		}
+	}
+	for(x = np->state.layer - 1; x >= LAYER_BOTTOM; x--) {
+		for(tp = nodes[x]; tp; tp = tp->next) {
+			if((tp->state.status & (STAT_MAPPED | STAT_SHADED))
+				&& !(tp->state.status & STAT_HIDDEN)) {
+				FocusClient(tp);
+				return;
+			}
+		}
+	}
+
+}
+
+/** Refocus the active client (if there is one). */
+void RefocusClient() {
+
+	if(activeClient) {
+		FocusClient(activeClient);
+	}
+
+}
+
+/** Send a delete message to a client. */
+void DeleteClient(ClientNode *np) {
+
+	ClientProtocolType protocols;
+
+	Assert(np);
+
+	protocols = ReadWMProtocols(np->window);
+	if(protocols & PROT_DELETE) {
+		SendClientMessage(np->window, ATOM_WM_PROTOCOLS,
+			ATOM_WM_DELETE_WINDOW);
+	} else {
+		KillClient(np);
+	}
+
+}
+
+/** Callback to kill a client after a confirm dialog. */
+void KillClientHandler(ClientNode *np) {
+
+	Assert(np);
+
+	if(np == activeClient) {
+		FocusNextStacked(np);
+	}
+
+	JXGrabServer(display);
+	JXSync(display, False);
+
+	JXKillClient(display, np->window);
+
+	JXSync(display, True);
+	JXUngrabServer(display);
+
+	RemoveClient(np);
+
+}
+
+/** Kill a client window. */
+void KillClient(ClientNode *np) {
+
+	Assert(np);
+
+	ShowConfirmDialog(np, KillClientHandler,
+		"Kill this window?",
+		"This may cause data to be lost!",
+		NULL);
+}
+
+/** Raise the client. This will affect transients. */
+void RaiseClient(ClientNode *np) {
+
+	ClientNode *tp, *next;
+	int x;
+
+	Assert(np);
+
+	if(nodes[np->state.layer] != np) {
+
+		/* Raise the window */
+		Assert(np->prev);
+		np->prev->next = np->next;
+		if(np->next) {
+			np->next->prev = np->prev;
+		} else {
+			nodeTail[np->state.layer] = np->prev;
+		}
+		np->next = nodes[np->state.layer];
+		nodes[np->state.layer]->prev = np;
+		np->prev = NULL;
+		nodes[np->state.layer] = np;
+
+		/* Place any transient windows on top of the owner */
+		for(x = 0; x < LAYER_COUNT; x++) {
+			for(tp = nodes[x]; tp; tp = tp->next) {
+				if(tp->owner == np->window && tp->prev) {
+
+					next = tp->next;
+
+					tp->prev->next = tp->next;
+					if(tp->next) {
+						tp->next->prev = tp->prev;
+					} else {
+						nodeTail[tp->state.layer] = tp->prev;
+					}
+					tp->next = nodes[tp->state.layer];
+					nodes[tp->state.layer]->prev = tp;
+					tp->prev = NULL;
+					nodes[tp->state.layer] = tp;
+
+					tp = next;
+
+				}
+
+				/* tp will be tp->next if the above code is executed. */
+				/* Thus, if it is NULL, we are done with this layer. */
+				if(!tp) {
+					break;
+				}
+			}
+		}
+
+		RestackClients();
+	}
+
+}
+
+/** Lower the client. This will not affect transients. */
+void LowerClient(ClientNode *np) {
+
+	ClientNode *tp;
+
+	Assert(np);
+
+	if(nodeTail[np->state.layer] != np) {
+
+		Assert(np->next);
+
+		/* Take the client out of the list. */
+		if(np->prev) {
+			np->prev->next = np->next;
+		} else {
+			nodes[np->state.layer] = np->next;
+		}
+		np->next->prev = np->prev;
+
+		/* Place the client at the end of the list. */
+		tp = nodeTail[np->state.layer];
+		nodeTail[np->state.layer] = np;
+		tp->next = np;
+		np->prev = tp;
+		np->next = NULL;
+
+		RestackClients();
+
+	}
+
+}
+
+/** Restack the clients according the way we want them. */
+void RestackClients() {
+
+	TrayType *tp;
+	ClientNode *np;
+	unsigned int layer, index;
+	int trayCount;
+	Window *stack;
+
+	/* Determine how many tray windows exist. */
+	trayCount = 0;
+	for(tp = GetTrays(); tp; tp = tp->next) {
+		++trayCount;
+	}
+
+	/** Allocate memory for restacking. */
+	stack = AllocateStack((clientCount + trayCount) * sizeof(Window));
+
+	/* Prepare the stacking array. */
+	index = 0;
+	layer = LAYER_TOP;
+	for(;;) {
+
+		for(np = nodes[layer]; np; np = np->next) {
+			if((np->state.status & (STAT_MAPPED | STAT_SHADED))
+				&& !(np->state.status & STAT_HIDDEN)) {
+				stack[index++] = np->parent;
+			}
+		}
+
+		for(tp = GetTrays(); tp; tp = tp->next) {
+			if(layer == tp->layer) {
+				stack[index++] = tp->window;
+			}
+		}
+
+		if(layer == 0) {
+			break;
+		}
+		--layer;
+
+	}
+
+	JXRestackWindows(display, stack, index);
+
+	ReleaseStack(stack);
+
+	UpdateNetClientList();
+
+}
+
+/** Send a client message to a window. */
+void SendClientMessage(Window w, AtomType type, AtomType message) {
+
+	XEvent event;
+	int status;
+
+	memset(&event, 0, sizeof(event));
+	event.xclient.type = ClientMessage;
+	event.xclient.window = w;
+	event.xclient.message_type = atoms[type];
+	event.xclient.format = 32;
+	event.xclient.data.l[0] = atoms[message];
+	event.xclient.data.l[1] = CurrentTime;
+
+	status = JXSendEvent(display, w, False, 0, &event);
+	if(status == False) {
+		Debug("SendClientMessage failed");
+	}
+
+}
+
+/** Set the border shape for windows using the shape extension. */
+#ifdef USE_SHAPE
+void SetShape(ClientNode *np) {
+
+	XRectangle rect[4];
+	int north, south, east, west;
+
+	Assert(np);
+
+	np->state.status |= STAT_SHAPE;
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	/* Shaded windows are a special case. */
+	if(np->state.status & STAT_SHADED) {
+
+		rect[0].x = 0;
+		rect[0].y = 0;
+		rect[0].width = np->width + east + west;
+		rect[0].height = north + south;
+
+		JXShapeCombineRectangles(display, np->parent, ShapeBounding,
+			0, 0, rect, 1, ShapeSet, Unsorted);
+
+		return;
+	}
+
+	/* Add the shape of window. */
+	JXShapeCombineShape(display, np->parent, ShapeBounding, west, north,
+		np->window, ShapeBounding, ShapeSet);
+
+	/* Add the shape of the border. */
+	if(north > 0) {
+
+		/* Top */
+		rect[0].x = 0;
+		rect[0].y = 0;
+		rect[0].width = np->width + east + west;
+		rect[0].height = north;
+
+		/* Left */
+		rect[1].x = 0;
+		rect[1].y = 0;
+		rect[1].width = west;
+		rect[1].height = np->height + north + south;
+
+		/* Right */
+		rect[2].x = np->width + east;
+		rect[2].y = 0;
+		rect[2].width = west;
+		rect[2].height = np->height + north + south;
+
+		/* Bottom */
+		rect[3].x = 0;
+		rect[3].y = np->height + north;
+		rect[3].width = np->width + east + west;
+		rect[3].height = south;
+
+		JXShapeCombineRectangles(display, np->parent, ShapeBounding,
+			0, 0, rect, 4, ShapeUnion, Unsorted);
+
+	}
+
+}
+#endif /* USE_SHAPE */
+
+/** Remove a client window from management. */
+void RemoveClient(ClientNode *np) {
+
+	ColormapNode *cp;
+
+	Assert(np);
+	Assert(np->window != None);
+	Assert(np->parent != None);
+
+	JXGrabServer(display);
+
+	/* Remove this client from the client list */
+	if(np->next) {
+		np->next->prev = np->prev;
+	} else {
+		nodeTail[np->state.layer] = np->prev;
+	}
+	if(np->prev) {
+		np->prev->next = np->next;
+	} else {
+		nodes[np->state.layer] = np->next;
+	}
+	--clientCount;
+	XDeleteContext(display, np->window, clientContext);
+	XDeleteContext(display, np->parent, frameContext);
+
+	/* Make sure this client isn't active */
+	if(activeClient == np && !shouldExit) {
+		FocusNextStacked(np);
+	}
+	if(activeClient == np) {
+		SetWindowAtom(rootWindow, ATOM_NET_ACTIVE_WINDOW, None);
+		activeClient = NULL;
+	}
+
+	/* If the window manager is exiting (ie, not the client), then
+	 * reparent etc. */
+	if(shouldExit && !(np->state.status & STAT_WMDIALOG)) {
+		if(np->state.status & STAT_MAXIMIZED) {
+			np->x = np->oldx;
+			np->y = np->oldy;
+			np->width = np->oldWidth;
+			np->height = np->oldHeight;
+			JXMoveResizeWindow(display, np->window,
+				np->x, np->y, np->width, np->height);
+		}
+		GravitateClient(np, 1);
+		if(!(np->state.status & STAT_MAPPED)
+			&& (np->state.status & (STAT_MINIMIZED | STAT_SHADED))) {
+			JXMapWindow(display, np->window);
+		}
+		JXUngrabButton(display, AnyButton, AnyModifier, np->window);
+		JXReparentWindow(display, np->window, rootWindow, np->x, np->y);
+		JXRemoveFromSaveSet(display, np->window);
+	}
+
+	/* Destroy the parent */
+	if(np->parent) {
+		JXDestroyWindow(display, np->parent);
+	}
+
+	if(np->name) {
+		JXFree(np->name);
+	}
+	if(np->instanceName) {
+		JXFree(np->instanceName);
+	}
+	if(np->className) {
+		JXFree(np->className);
+	}
+
+	RemoveClientFromTaskBar(np);
+	RemoveClientStrut(np);
+	UpdatePager();
+
+	while(np->colormaps) {
+		cp = np->colormaps->next;
+		Release(np->colormaps);
+		np->colormaps = cp;
+	}
+
+	DestroyIcon(np->icon);
+
+	Release(np);
+
+	JXUngrabServer(display);
+
+}
+
+/** Get the active client (possibly NULL). */
+ClientNode *GetActiveClient() {
+
+	return activeClient;
+
+}
+
+/** Find a client given a window (searches frame windows too). */
+ClientNode *FindClientByWindow(Window w) {
+
+	ClientNode *np;
+
+	if(!XFindContext(display, w, clientContext, (void*)&np)) {
+		return np;
+	} else {
+		return FindClientByParent(w);
+	}
+
+}
+
+/** Find a client by its frame window. */
+ClientNode *FindClientByParent(Window p) {
+
+	ClientNode *np;
+
+	if(!XFindContext(display, p, frameContext, (void*)&np)) {
+		return np;
+	} else {
+		return NULL;
+	}
+
+}
+
+/** Reparent a client window. */
+void ReparentClient(ClientNode *np, int notOwner) {
+
+	XSetWindowAttributes attr;
+	int attrMask;
+	int x, y, width, height;
+
+	Assert(np);
+
+	if(notOwner) {
+		JXAddToSaveSet(display, np->window);
+
+		attr.event_mask = EnterWindowMask | ColormapChangeMask
+			| PropertyChangeMask | StructureNotifyMask;
+		attr.do_not_propagate_mask = NoEventMask;
+		XChangeWindowAttributes(display, np->window,
+			CWEventMask | CWDontPropagate, &attr);
+
+	}
+	JXGrabButton(display, AnyButton, AnyModifier, np->window,
+		True, ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
+	GrabKeys(np);
+
+	attrMask = 0;
+
+	attrMask |= CWOverrideRedirect;
+	attr.override_redirect = True;
+
+	/* We can't use PointerMotionHint mask here since the exact location
+	 * of the mouse on the frame is important. */
+	attrMask |= CWEventMask;
+	attr.event_mask
+		= ButtonPressMask
+		| ButtonReleaseMask
+		| ExposureMask
+		| PointerMotionMask
+		| SubstructureRedirectMask
+		| SubstructureNotifyMask
+		| EnterWindowMask
+		| LeaveWindowMask
+		| KeyPressMask;
+
+	attrMask |= CWDontPropagate;
+	attr.do_not_propagate_mask = ButtonPressMask | ButtonReleaseMask;
+
+	attrMask |= CWBackPixel;
+	attr.background_pixel = colors[COLOR_BORDER_BG];
+
+	x = np->x;
+	y = np->y;
+	width = np->width;
+	height = np->height;
+	if(np->state.border & BORDER_OUTLINE) {
+		x -= borderWidth;
+		y -= borderWidth;
+		width += borderWidth * 2;
+		height += borderWidth * 2;
+	}
+	if(np->state.border & BORDER_TITLE) {
+		y -= titleHeight;
+		height += titleHeight;
+	}
+
+	/* Create the frame window. */
+	np->parent = JXCreateWindow(display, rootWindow,
+		x, y, width, height, 0, rootDepth, InputOutput,
+		rootVisual, attrMask, &attr);
+
+	/* Update the window to get only the events we want. */
+	attrMask = CWDontPropagate;
+	attr.do_not_propagate_mask
+		= ButtonPressMask
+		| ButtonReleaseMask
+		| PointerMotionMask
+		| ButtonMotionMask
+		| KeyPressMask;
+	JXChangeWindowAttributes(display, np->window, attrMask, &attr);
+	JXSetWindowBorderWidth(display, np->window, 0);
+
+	/* Reparent the client window. */
+	if((np->state.border & BORDER_OUTLINE)
+		&& (np->state.border & BORDER_TITLE)) {
+		JXReparentWindow(display, np->window, np->parent,
+			borderWidth, borderWidth + titleHeight);
+	} else if(np->state.border & BORDER_OUTLINE) {
+		JXReparentWindow(display, np->window, np->parent,
+			borderWidth, borderWidth);
+	} else if(np->state.border & BORDER_TITLE) {
+		JXReparentWindow(display, np->window, np->parent,
+			0, titleHeight);
+	} else {
+		JXReparentWindow(display, np->window, np->parent, 0, 0);
+	}
+
+#ifdef USE_SHAPE
+	if(haveShape) {
+		JXShapeSelectInput(display, np->window, ShapeNotifyMask);
+		CheckShape(np);
+	}
+#endif
+
+}
+
+/** Determine if a window uses the shape extension. */
+#ifdef USE_SHAPE
+void CheckShape(ClientNode *np) {
+
+	int xb, yb;
+	int xc, yc;
+	unsigned int wb, hb;
+	unsigned int wc, hc;
+	Bool boundingShaped, clipShaped;
+
+	JXShapeQueryExtents(display, np->window, &boundingShaped,
+		&xb, &yb, &wb, &hb, &clipShaped, &xc, &yc, &wc, &hc);
+
+	if(boundingShaped == True) {
+		SetShape(np);
+	}
+
+}
+#endif
+
+/** Send a configure event to a client window. */
+void SendConfigureEvent(ClientNode *np) {
+
+	XConfigureEvent event;
+	const ScreenType *sp;
+
+	Assert(np);
+
+	event.type = ConfigureNotify;
+	event.event = np->window;
+	event.window = np->window;
+
+	if(np->state.status & STAT_FULLSCREEN) {
+		sp = GetCurrentScreen(np->x, np->y);
+		event.x = sp->x;
+		event.y = sp->y;
+		event.width = sp->width;
+		event.height = sp->height;
+	} else {
+		event.x = np->x;
+		event.y = np->y;
+		event.width = np->width;
+		event.height = np->height;
+	}
+
+	event.border_width = 0;
+	event.above = None;
+	event.override_redirect = False;
+
+	JXSendEvent(display, np->window, False, StructureNotifyMask,
+		(XEvent*)&event);
+
+}
+
+/** Update a window's colormap.
+ * A call to this function indicates that the colormap(s) for the given
+ * client changed. This will change the active colormap(s) if the given
+ * client is active.
+ */
+void UpdateClientColormap(ClientNode *np) {
+
+	XWindowAttributes attr;
+	ColormapNode *cp;
+	int wasInstalled;
+
+	Assert(np);
+
+	cp = np->colormaps;
+
+	if(np == activeClient) {
+
+		wasInstalled = 0;
+		cp = np->colormaps;
+		while(cp) {
+			if(JXGetWindowAttributes(display, cp->window, &attr)) {
+				if(attr.colormap != None) {
+					if(attr.colormap == np->cmap) {
+						wasInstalled = 1;
+					}
+					JXInstallColormap(display, attr.colormap);
+				}
+			}
+			cp = cp->next;
+		}
+
+		if(!wasInstalled && np->cmap != None) {
+			JXInstallColormap(display, np->cmap);
+		}
+
+	}
+
+}
+
diff --git a/src/client.h b/src/client.h
new file mode 100644
index 0000000..7fc98db
--- /dev/null
+++ b/src/client.h
@@ -0,0 +1,285 @@
+/**
+ * @file client.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header file client window functions.
+ *
+ */
+
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include "border.h"
+#include "hint.h"
+
+/** Window border flags. */
+typedef enum {
+	BORDER_NONE    = 0,
+	BORDER_OUTLINE = 1,  /**< Window has a border. */
+	BORDER_TITLE   = 2,  /**< Window has a title bar. */
+	BORDER_MIN     = 4,  /**< Window supports minimize. */
+	BORDER_MAX     = 8,  /**< Window supports maximize. */
+	BORDER_CLOSE   = 16, /**< Window supports close. */
+	BORDER_RESIZE  = 32, /**< Window supports resizing. */
+	BORDER_MOVE    = 64  /**< Window supports moving. */
+} BorderFlags;
+
+/** The default border flags. */
+#define BORDER_DEFAULT ( \
+		  BORDER_OUTLINE \
+		| BORDER_TITLE   \
+		| BORDER_MIN     \
+		| BORDER_MAX     \
+		| BORDER_CLOSE   \
+		| BORDER_RESIZE  \
+		| BORDER_MOVE    )
+
+/** Window status flags. */
+typedef enum {
+	STAT_NONE       = 0,
+	STAT_ACTIVE     = 1 << 0,  /**< This client has focus. */
+	STAT_MAPPED     = 1 << 1,  /**< This client is shown (on some desktop). */
+	STAT_MAXIMIZED  = 1 << 2,  /**< This client is maximized. */
+	STAT_HIDDEN     = 1 << 3,  /**< This client is not on the current desktop. */
+	STAT_STICKY     = 1 << 4,  /**< This client is on all desktops. */
+	STAT_NOLIST     = 1 << 5,  /**< Skip this client in the task list. */
+	STAT_MINIMIZED  = 1 << 6,  /**< This client is minimized. */
+	STAT_SHADED     = 1 << 7,  /**< This client is shaded. */
+	STAT_WMDIALOG   = 1 << 8,  /**< This is a JWM dialog window. */
+	STAT_PIGNORE    = 1 << 9,  /**< Ignore the program-specified position. */
+	STAT_SHAPE      = 1 << 10, /**< This client uses the shape extension. */
+	STAT_SDESKTOP   = 1 << 11, /**< This client was minimized to show desktop. */
+	STAT_FULLSCREEN = 1 << 12  /**< This client wants to be full screen. */
+} StatusFlags;
+
+/** Colormap window linked list. */
+typedef struct ColormapNode {
+	Window window;             /**< A window containing a colormap. */
+	struct ColormapNode *next; /**< Next value in the linked list. */
+} ColormapNode;
+
+/** The aspect ratio of a window. */
+typedef struct AspectRatio {
+	int minx, miny;  /**< The minimum aspect ratio. */
+	int maxx, maxy;  /**< The maximum aspect ratio. */
+} AspectRatio;
+
+/** Struture to store information about a client window. */
+typedef struct ClientNode {
+
+	Window window;           /**< The client window. */
+	Window parent;           /**< The frame window. */
+
+	Window owner;            /**< The owner window (for transients). */
+
+	int x, y;                /**< The location of the window. */
+	int width, height;       /**< The size of the window. */
+	int oldx, oldy;          /**< The old location (for maximize). */
+	int oldWidth, oldHeight; /**< The old size (for maximize). */
+
+	long sizeFlags;
+	int baseWidth, baseHeight;
+	int minWidth, minHeight;
+	int maxWidth, maxHeight;
+	int xinc, yinc;
+	AspectRatio aspect;
+	int gravity;
+
+	Colormap cmap;
+	ColormapNode *colormaps;
+
+	char *name;
+	char *instanceName;
+	char *className;
+
+	ClientState state;
+
+	BorderActionType borderAction;
+
+	struct IconNode *icon;
+
+	void (*controller)(int wasDestroyed);
+
+	struct ClientNode *prev;  /**< The previous client in this layer. */
+	struct ClientNode *next;  /**< The next client in this layer. */
+
+} ClientNode;
+
+/** Client windows in linked lists for each layer. */
+extern ClientNode *nodes[LAYER_COUNT];
+
+/** Client windows in linked lists for each layer (pointer to the tail). */
+extern ClientNode *nodeTail[LAYER_COUNT];
+
+/** Find a client by window or parent window.
+ * @param w The window.
+ * @return The client (NULL if not found).
+ */
+ClientNode *FindClientByWindow(Window w);
+
+/** Find a client by its parent window.
+ * @param p The parent window.
+ * @return The client (NULL if not found).
+ */
+ClientNode *FindClientByParent(Window p);
+
+/** Get the active client.
+ * @return The active client (NULL if no client is active).
+ */
+ClientNode *GetActiveClient();
+
+void InitializeClients();
+void StartupClients();
+void ShutdownClients();
+void DestroyClients();
+
+/** Add a window to management.
+ * @param w The client window.
+ * @param alreadyMapped 1 if the window is mapped, 0 if not.
+ * @param notOwner 1 if JWM doesn't own this window, 0 if JWM is the owner.
+ * @return The client window data.
+ */
+ClientNode *AddClientWindow(Window w, int alreadyMapped, int notOwner);
+
+/** Remove a client from management.
+ * @param np The client to remove.
+ */
+void RemoveClient(ClientNode *np);
+
+/** Minimize a client.
+ * @param np The client to minimize.
+ */
+void MinimizeClient(ClientNode *np);
+
+/** Shade a client.
+ * @param np The client to shade.
+ */
+void ShadeClient(ClientNode *np);
+
+/** Unshade a client.
+ * @param np The client to unshade.
+ */
+void UnshadeClient(ClientNode *np);
+
+/** Set a client's status to withdrawn.
+ * A withdrawn client is a client that is not visible in any way to the
+ * user. This may be a window that an application keeps around so that
+ * it can be reused at a later time.
+ * @param np The client whose status to change.
+ */
+void SetClientWithdrawn(ClientNode *np);
+
+/** Restore a client from minimized state.
+ * @param np The client to restore.
+ * @param raise 1 to raise the client, 0 to leave stacking unchanged.
+ */
+void RestoreClient(ClientNode *np, int raise);
+
+/** Maximize a client.
+ * @param np The client to maximize.
+ */
+void MaximizeClient(ClientNode *np);
+
+/** Set the full screen status of a client.
+ * @param np The client.
+ * @param fullScreen 1 to make full screen, 0 to make not full screen.
+ */
+void SetClientFullScreen(ClientNode *np, int fullScreen);
+
+/** Set the keyboard focus to a client.
+ * @param np The client to focus.
+ */
+void FocusClient(ClientNode *np);
+
+/** Set the keyboard focus to the next client.
+ * This is used to focus the next client in the stacking order.
+ * @param np The client before the client to focus.
+ */
+void FocusNextStacked(ClientNode *np);
+
+/** Set the keyboard focus back to the active client. */
+void RefocusClient();
+
+/** Tell a client to exit.
+ * @param np The client to delete.
+ */
+void DeleteClient(ClientNode *np);
+
+/** Force a client to exit.
+ * @param np The client to kill.
+ */
+void KillClient(ClientNode *np);
+
+/** Raise a client to the top of its layer.
+ * @param np The client to raise.
+ */
+void RaiseClient(ClientNode *np);
+
+/** Lower a client to the bottom of its layer.
+ * @param np The client to lower.
+ */
+void LowerClient(ClientNode *np);
+
+/** Restack the clients.
+ * This is used when a client is mapped so that the stacking order
+ * remains consistent.
+ */
+void RestackClients();
+
+/** Set the layer of a client.
+ * @param np The client whose layer to set.
+ * @param layer the layer to assign to the client.
+ */
+void SetClientLayer(ClientNode *np, unsigned int layer);
+
+/** Set the desktop for a client.
+ * @param np The client.
+ * @parma desktop The desktop to be assigned to the client.
+ */
+void SetClientDesktop(ClientNode *np, unsigned int desktop);
+
+/** Set the sticky status of a client.
+ * A sticky client will appear on all desktops.
+ * @param np The client.
+ * @param isSticky 1 to make the client sticky, 0 to make it not sticky.
+ */
+void SetClientSticky(ClientNode *np, int isSticky);
+
+/** Hide a client.
+ * This is used for changing desktops.
+ * @param np The client to hide.
+ */
+void HideClient(ClientNode *np);
+
+/** Show a client.
+ * This is used for changing desktops.
+ * @param np The client to show.
+ */
+void ShowClient(ClientNode *np);
+
+/** Update a client's colormap.
+ * @param np The client.
+ */
+void UpdateClientColormap(ClientNode *np);
+
+/** Update the shape of a client using the shape extension.
+ * @param np The client to update.
+ */
+void SetShape(ClientNode *np);
+
+/** Send a configure event to a client.
+ * This will send updated location and size information to a client.
+ * @param np The client to get the event.
+ */
+void SendConfigureEvent(ClientNode *np);
+
+/** Send a message to a client.
+ * @param w The client window.
+ * @param type The type of message to send.
+ * @param message The message to send.
+ */
+void SendClientMessage(Window w, AtomType type, AtomType message);
+
+#endif
+
diff --git a/src/clock.c b/src/clock.c
new file mode 100644
index 0000000..147c1f6
--- /dev/null
+++ b/src/clock.c
@@ -0,0 +1,332 @@
+/**
+ * @file clock.c
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Clock tray component.
+ *
+ */
+
+#include "jwm.h"
+#include "clock.h"
+#include "tray.h"
+#include "color.h"
+#include "font.h"
+#include "timing.h"
+#include "main.h"
+#include "root.h"
+#include "cursor.h"
+#include "popup.h"
+#include "misc.h"
+
+/** Structure to respresent a clock tray component. */
+typedef struct ClockType {
+
+	TrayComponentType *cp;   /**< Common component data. */
+
+	char *format;            /**< The time format to use. */
+	char *command;           /**< A command to run when clicked. */
+	char shortTime[80];      /**< Currently displayed time. */
+
+	/* The following are used to control popups. */
+	int mousex;              /**< Last mouse x-coordinate. */
+	int mousey;              /**< Last mouse y-coordinate. */
+	TimeType mouseTime;      /**< Time of the last mouse motion. */
+
+	int userWidth;           /**< User-specified clock width (or 0). */
+
+	struct ClockType *next;  /**< Next clock in the list. */
+
+} ClockType;
+
+/** The default time format to use. */
+static const char *DEFAULT_FORMAT = "%I:%M %p";
+
+static ClockType *clocks;
+static TimeType lastUpdate = ZERO_TIME;
+
+static void Create(TrayComponentType *cp);
+static void Resize(TrayComponentType *cp);
+static void Destroy(TrayComponentType *cp);
+static void ProcessClockButtonEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+static void ProcessClockMotionEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+
+static void DrawClock(ClockType *clk, const TimeType *now, int x, int y);
+
+/** Initialize clocks. */
+void InitializeClock() {
+	clocks = NULL;
+}
+
+/** Start clock(s). */
+void StartupClock() {
+
+	ClockType *clk;
+
+	for(clk = clocks; clk; clk = clk->next) {
+		if(clk->cp->requestedWidth == 0) {
+			clk->cp->requestedWidth = GetStringWidth(FONT_CLOCK, clk->format) + 4;
+		}
+		if(clk->cp->requestedHeight == 0) {
+			clk->cp->requestedHeight = GetStringHeight(FONT_CLOCK) + 4;
+		}
+	}
+
+}
+
+/** Stop clock(s). */
+void ShutdownClock() {
+}
+
+/** Destroy clock(s). */
+void DestroyClock() {
+
+	ClockType *cp;
+
+	while(clocks) {
+		cp = clocks->next;
+
+		if(clocks->format) {
+			Release(clocks->format);
+		}
+		if(clocks->command) {
+			Release(clocks->command);
+		}
+
+		Release(clocks);
+		clocks = cp;
+	}
+
+}
+
+/** Create a clock tray component. */
+TrayComponentType *CreateClock(const char *format, const char *command,
+	int width, int height) {
+
+	TrayComponentType *cp;
+	ClockType *clk;
+
+	clk = Allocate(sizeof(ClockType));
+	clk->next = clocks;
+	clocks = clk;
+
+	clk->mousex = 0;
+	clk->mousey = 0;
+	clk->mouseTime.seconds = 0;
+	clk->mouseTime.ms = 0;
+	clk->userWidth = 0;
+
+	if(!format) {
+		format = DEFAULT_FORMAT;
+	}
+	clk->format = CopyString(format);
+
+	clk->command = CopyString(command);
+
+	clk->shortTime[0] = 0;
+
+	cp = CreateTrayComponent();
+	cp->object = clk;
+	clk->cp = cp;
+	if(width > 0) {
+		cp->requestedWidth = width;
+		clk->userWidth = 1;
+	} else {
+		cp->requestedWidth = 0;
+		clk->userWidth = 0;
+	}
+	cp->requestedHeight = height;
+
+	cp->Create = Create;
+	cp->Resize = Resize;
+	cp->Destroy = Destroy;
+	cp->ProcessButtonEvent = ProcessClockButtonEvent;
+	cp->ProcessMotionEvent = ProcessClockMotionEvent;
+
+	return cp;
+
+}
+
+/** Initialize a clock tray component. */
+void Create(TrayComponentType *cp) {
+
+	ClockType *clk;
+
+	Assert(cp);
+
+	clk = (ClockType*)cp->object;
+
+	Assert(clk);
+
+	cp->pixmap = JXCreatePixmap(display, rootWindow, cp->width, cp->height,
+		rootDepth);
+
+	JXSetForeground(display, rootGC, colors[COLOR_CLOCK_BG]);
+	JXFillRectangle(display, cp->pixmap, rootGC, 0, 0, cp->width, cp->height);
+
+}
+
+/** Resize a clock tray component. */
+void Resize(TrayComponentType *cp) {
+
+	ClockType *clk;
+	TimeType now;
+	int x, y;
+
+	Assert(cp);
+
+	clk = (ClockType*)cp->object;
+
+	Assert(clk);
+
+	if(cp->pixmap != None) {
+		JXFreePixmap(display, cp->pixmap);
+	}
+
+	cp->pixmap = JXCreatePixmap(display, rootWindow, cp->width, cp->height,
+		rootDepth);
+
+	clk->shortTime[0] = 0;
+
+	GetCurrentTime(&now);
+	GetMousePosition(&x, &y);
+	DrawClock(clk, &now, x, y);
+
+}
+
+/** Destroy a clock tray component. */
+void Destroy(TrayComponentType *cp) {
+
+	ClockType *clk;
+
+	Assert(cp);
+
+	clk = (ClockType*)cp->object;
+
+	Assert(clk);
+
+	if(cp->pixmap != None) {
+		JXFreePixmap(display, cp->pixmap);
+	}
+}
+
+/** Process a click event on a clock tray component. */
+void ProcessClockButtonEvent(TrayComponentType *cp, int x, int y, int mask) {
+
+	ClockType *clk;
+
+	Assert(cp);
+
+	clk = (ClockType*)cp->object;
+
+	Assert(clk);
+
+	if(clk->command) {
+		RunCommand(clk->command);
+	}
+
+}
+
+/** Process a motion event on a clock tray component. */
+void ProcessClockMotionEvent(TrayComponentType *cp,
+	int x, int y, int mask) {
+
+	Assert(cp);
+
+	ClockType *clk = (ClockType*)cp->object;
+	clk->mousex = cp->screenx + x;
+	clk->mousey = cp->screeny + y;
+	GetCurrentTime(&clk->mouseTime);
+
+}
+
+/** Update a clock tray component. */
+void SignalClock(const TimeType *now, int x, int y) {
+
+	ClockType *cp;
+	int shouldDraw;
+	char *longTime;
+	time_t t;
+
+	Assert(now);
+
+	/* Determine if we should update the clock(s). */
+	if(GetTimeDifference(&lastUpdate, now) > 900) {
+		shouldDraw = 1;
+		lastUpdate = *now;
+	} else {
+		shouldDraw = 0;
+	}
+
+	/* Update each clock. */
+	for(cp = clocks; cp; cp = cp->next) {
+
+		if(shouldDraw) {
+			DrawClock(cp, now, x, y);
+		}
+
+		if(abs(cp->mousex - x) < POPUP_DELTA
+			&& abs(cp->mousey - y) < POPUP_DELTA) {
+			if(GetTimeDifference(now, &cp->mouseTime) >= popupDelay) {
+				time(&t);
+				longTime = asctime(localtime(&t));
+				Trim(longTime);
+				ShowPopup(x, y, longTime);
+			}
+		}
+
+	}
+
+}
+
+/** Draw a clock tray component. */
+void DrawClock(ClockType *clk, const TimeType *now, int x, int y) {
+
+	TrayComponentType *cp;
+	const char *shortTime;
+	int width;
+	int rwidth;
+
+	Assert(clk);
+	Assert(now);
+
+	/* Only draw if the label changed. */
+	shortTime = GetTimeString(clk->format);
+	if(!strcmp(clk->shortTime, shortTime)) {
+		return;
+	}
+	strcpy(clk->shortTime, shortTime);
+
+	cp = clk->cp;
+
+	/* Clear the area. */
+	JXSetForeground(display, rootGC, colors[COLOR_CLOCK_BG]);
+	JXFillRectangle(display, cp->pixmap, rootGC, 0, 0,
+		cp->width, cp->height);
+
+	/* Determine if the clock is the right size. */
+	width = GetStringWidth(FONT_CLOCK, shortTime);
+	rwidth = width + 4;
+	if(rwidth == clk->cp->requestedWidth || clk->userWidth) {
+
+		/* Draw the clock. */
+		RenderString(cp->pixmap, FONT_CLOCK, COLOR_CLOCK_FG,
+			cp->width / 2 - width / 2,
+			cp->height / 2 - GetStringHeight(FONT_CLOCK) / 2,
+			cp->width, NULL, shortTime);
+
+		UpdateSpecificTray(clk->cp->tray, clk->cp);
+
+	} else {
+
+		/* Wrong size. Resize. */
+		clk->cp->requestedWidth = rwidth;
+		ResizeTray(clk->cp->tray);
+
+	}
+
+}
+
+
diff --git a/src/clock.h b/src/clock.h
new file mode 100644
index 0000000..25bd74d
--- /dev/null
+++ b/src/clock.h
@@ -0,0 +1,41 @@
+/**
+ * @file clock.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Clock tray component.
+ *
+ */
+
+#ifndef CLOCK_H
+#define CLOCK_H
+
+struct TrayComponentType;
+struct TimeType;
+
+/*@{*/
+void InitializeClock();
+void StartupClock();
+void ShutdownClock();
+void DestroyClock();
+/*@}*/
+
+/** Create a clock component for the tray.
+ * @param format The format of the clock.
+ * @param command The command to execute when the clock is clicked.
+ * @param width The width of the clock (0 for auto).
+ * @param height The height of the clock (0 for auto).
+ */
+struct TrayComponentType *CreateClock(const char *format,
+	const char *command, int width, int height);
+
+/** Update clocks.
+ * This is called on a regular basis to update the time.
+ * @param now The current time.
+ * @param x The x-coordinate of the mouse.
+ * @param y The y-coordinate of the mouse.
+ */
+void SignalClock(const struct TimeType *now, int x, int y);
+
+#endif
+
diff --git a/src/color.c b/src/color.c
new file mode 100644
index 0000000..edf5f7a
--- /dev/null
+++ b/src/color.c
@@ -0,0 +1,606 @@
+/****************************************************************************
+ * Functions to handle loading colors.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "main.h"
+#include "color.h"
+#include "error.h"
+#include "misc.h"
+
+typedef struct {
+	ColorType type;
+	const char *value;
+} DefaultColorNode;
+
+static const float COLOR_DELTA = 0.45;
+
+unsigned long colors[COLOR_COUNT];
+static unsigned long rgbColors[COLOR_COUNT];
+
+static unsigned long *map;
+
+#ifdef USE_XFT
+static XftColor *xftColors[COLOR_COUNT] = { NULL };
+#endif
+
+static DefaultColorNode DEFAULT_COLORS[] = {
+	{ COLOR_BORDER_BG,          "gray"    },
+	{ COLOR_BORDER_FG,          "black"   },
+	{ COLOR_BORDER_ACTIVE_BG,   "red"     },
+	{ COLOR_BORDER_ACTIVE_FG,   "white"   },
+	{ COLOR_TRAY_BG,            "gray"    },
+	{ COLOR_TRAY_FG,            "black"   },
+	{ COLOR_TASK_BG,            "gray"    },
+	{ COLOR_TASK_FG,            "black"   },
+	{ COLOR_TASK_ACTIVE_BG,     "red"     },
+	{ COLOR_TASK_ACTIVE_FG,     "white"   },
+	{ COLOR_PAGER_BG,           "black"   },
+	{ COLOR_PAGER_FG,           "gray"    },
+	{ COLOR_PAGER_ACTIVE_BG,    "red"     },
+	{ COLOR_PAGER_ACTIVE_FG,    "red"     },
+	{ COLOR_PAGER_OUTLINE,      "black"   },
+	{ COLOR_MENU_BG,            "gray"    },
+	{ COLOR_MENU_FG,            "black"   },
+	{ COLOR_MENU_ACTIVE_BG,     "red"     },
+	{ COLOR_MENU_ACTIVE_FG,     "white"   },
+	{ COLOR_POPUP_BG,           "yellow"  },
+	{ COLOR_POPUP_FG,           "black"   },
+	{ COLOR_POPUP_OUTLINE,      "black"   },
+	{ COLOR_TRAYBUTTON_FG,      "black"   },
+	{ COLOR_TRAYBUTTON_BG,      "gray"    },
+	{ COLOR_CLOCK_FG,           "black"   },
+	{ COLOR_CLOCK_BG,           "gray"    },
+	{ COLOR_COUNT,              NULL      }
+};
+
+static char **names = NULL;
+
+static unsigned long redShift;
+static unsigned long greenShift;
+static unsigned long blueShift;
+static unsigned long redMask;
+static unsigned long greenMask;
+static unsigned long blueMask;
+
+static void ComputeShiftMask(unsigned long maskIn,
+	unsigned long *shiftOut, unsigned long *maskOut);
+
+static void GetDirectPixel(XColor *c);
+static void GetMappedPixel(XColor *c);
+
+static int ParseColor(ColorType type, const char *value);
+static void SetDefaultColor(ColorType type); 
+
+static unsigned long ReadHex(const char *hex);
+
+static unsigned long GetRGBFromXColor(const XColor *c);
+static XColor GetXColorFromRGB(unsigned long rgb);
+
+static int GetColorByName(const char *str, XColor *c);
+static void InitializeNames();
+
+static void LightenColor(ColorType oldColor, ColorType newColor);
+static void DarkenColor(ColorType oldColor, ColorType newColor);
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeColors() {
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupColors() {
+
+	int x;
+	int red, green, blue;
+	XColor c;
+
+	/* Determine how to convert between RGB triples and pixels. */
+	Assert(rootVisual);
+	switch(rootVisual->class) {
+	case DirectColor:
+	case TrueColor:
+		ComputeShiftMask(rootVisual->red_mask, &redShift, &redMask);
+		ComputeShiftMask(rootVisual->green_mask, &greenShift, &greenMask);
+		ComputeShiftMask(rootVisual->blue_mask, &blueShift, &blueMask);
+		map = NULL;
+		break;
+	default:
+
+		/* Attempt to get 256 colors, pretend it worked. */
+		redMask = 0xE0;
+		greenMask = 0x1C;
+		blueMask = 0x03;
+		ComputeShiftMask(redMask, &redShift, &redMask);
+		ComputeShiftMask(greenMask, &greenShift, &greenMask);
+		ComputeShiftMask(blueMask, &blueShift, &blueMask);
+		map = Allocate(sizeof(unsigned long) * 256);
+
+		/* RGB: 3, 3, 2 */
+		x = 0;
+		for(red = 0; red < 8; red++) {
+			for(green = 0; green < 8; green++) {
+				for(blue = 0; blue < 4; blue++) {
+					c.red = 74898 * red / 8;
+					c.green = 74898 * green / 8;
+					c.blue = 87381 * blue / 4;
+					c.flags = DoRed | DoGreen | DoBlue;
+					JXAllocColor(display, rootColormap, &c);
+					map[x] = c.pixel;
+					++x;
+				}
+			}
+		}
+
+		break;
+	}
+
+	/* Inherit unset colors from the tray for tray items. */
+	if(names) {
+		if(!names[COLOR_TASK_BG]) {
+			names[COLOR_TASK_BG] = CopyString(names[COLOR_TRAY_BG]);
+		}
+		if(!names[COLOR_TRAYBUTTON_BG]) {
+			names[COLOR_TRAYBUTTON_BG] = CopyString(names[COLOR_TRAY_BG]);
+		}
+		if(!names[COLOR_CLOCK_BG]) {
+			names[COLOR_CLOCK_BG] = CopyString(names[COLOR_TRAY_BG]);
+		}
+		if(!names[COLOR_TASK_FG]) {
+			names[COLOR_TASK_FG] = CopyString(names[COLOR_TRAY_FG]);
+		}
+		if(!names[COLOR_TRAYBUTTON_FG]) {
+			names[COLOR_TRAYBUTTON_FG] = CopyString(names[COLOR_TRAY_FG]);
+		}
+		if(!names[COLOR_CLOCK_FG]) {
+			names[COLOR_CLOCK_FG] = CopyString(names[COLOR_TRAY_FG]);
+		}
+	}
+
+	/* Get color information used for JWM stuff. */
+	for(x = 0; x < COLOR_COUNT; x++) {
+		if(names && names[x]) {
+			if(!ParseColor(x, names[x])) {
+				SetDefaultColor(x);
+			}
+		} else {
+			SetDefaultColor(x);
+		}
+	}
+
+	if(names) {
+		for(x = 0; x < COLOR_COUNT; x++) {
+			if(names[x]) {
+				Release(names[x]);
+			}
+		}
+		Release(names);
+		names = NULL;
+	}
+
+	LightenColor(COLOR_BORDER_BG, COLOR_BORDER_UP);
+	DarkenColor(COLOR_BORDER_BG, COLOR_BORDER_DOWN);
+
+	LightenColor(COLOR_BORDER_ACTIVE_BG, COLOR_BORDER_ACTIVE_UP);
+	DarkenColor(COLOR_BORDER_ACTIVE_BG, COLOR_BORDER_ACTIVE_DOWN);
+
+	LightenColor(COLOR_TRAY_BG, COLOR_TRAY_UP);
+	DarkenColor(COLOR_TRAY_BG, COLOR_TRAY_DOWN);
+
+	LightenColor(COLOR_TASK_BG, COLOR_TASK_UP);
+	DarkenColor(COLOR_TASK_BG, COLOR_TASK_DOWN);
+
+	LightenColor(COLOR_TASK_ACTIVE_BG, COLOR_TASK_ACTIVE_UP);
+	DarkenColor(COLOR_TASK_ACTIVE_BG, COLOR_TASK_ACTIVE_DOWN);
+
+	LightenColor(COLOR_MENU_BG, COLOR_MENU_UP);
+	DarkenColor(COLOR_MENU_BG, COLOR_MENU_DOWN);
+
+	LightenColor(COLOR_MENU_ACTIVE_BG, COLOR_MENU_ACTIVE_UP);
+	DarkenColor(COLOR_MENU_ACTIVE_BG, COLOR_MENU_ACTIVE_DOWN);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownColors() {
+
+#ifdef USE_XFT
+
+	int x;
+
+	for(x = 0; x < COLOR_COUNT; x++) {
+		if(xftColors[x]) {
+			JXftColorFree(display, rootVisual, rootColormap, xftColors[x]);
+			Release(xftColors[x]);
+			xftColors[x] = NULL;
+		}
+	}
+
+#endif
+
+	if(map != NULL) {
+		JXFreeColors(display, rootColormap, map, 256, 0);
+		Release(map);
+		map = NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyColors() {
+
+	int x;
+
+	if(names) {
+		for(x = 0; x < COLOR_COUNT; x++) {
+			if(names[x]) {
+				Release(names[x]);
+			}
+		}
+		Release(names);
+		names = NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ComputeShiftMask(unsigned long maskIn,
+	unsigned long *shiftOut, unsigned long *maskOut) {
+
+	int shift;
+
+	Assert(shiftOut);
+	Assert(maskOut);
+
+	/* Components are stored in 16 bits.
+	 * When computing pixels, we'll first shift left 16 bits
+	 * so to the shift will be an offset from that 32 bit entity.
+	 * shift = 16 - <shift-to-ones> + <shift-to-zeros>
+	 */
+
+	shift = 0;
+	*maskOut = maskIn;
+	while(maskIn && (maskIn & (1 << 31)) == 0) {
+		++shift;
+		maskIn <<= 1;
+	}
+	*shiftOut = shift;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+unsigned long GetRGBFromXColor(const XColor *c) {
+
+	float red, green, blue;
+	unsigned long rgb;
+
+	Assert(c);
+
+	red = (float)c->red / 65535.0;
+	green = (float)c->green / 65535.0;
+	blue = (float)c->blue / 65535.0;
+
+	rgb = (unsigned long)(red * 255.0) << 16;
+	rgb |= (unsigned long)(green * 255.0) << 8;
+	rgb |= (unsigned long)(blue * 255.0);
+
+	return rgb;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+XColor GetXColorFromRGB(unsigned long rgb) {
+
+	XColor ret = { 0 };
+
+	ret.flags = DoRed | DoGreen | DoBlue;
+	ret.red = (unsigned short)(((rgb >> 16) & 0xFF) * 257);
+	ret.green = (unsigned short)(((rgb >> 8) & 0xFF) * 257);
+	ret.blue = (unsigned short)((rgb & 0xFF) * 257);
+
+	return ret;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetColor(ColorType c, const char *value) {
+
+	if(!value) {
+		Warning("empty color tag");
+		return;
+	}
+
+	InitializeNames();
+
+	if(names[c]) {
+		Release(names[c]);
+	}
+
+	names[c] = CopyString(value);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int ParseColor(ColorType type, const char *value) {
+
+	XColor temp;
+	unsigned long rgb;
+
+	if(!value) {
+		return 0;
+	}
+
+	if(value[0] == '#' && strlen(value) == 7) {
+		rgb = ReadHex(value + 1);
+		temp.red = ((rgb >> 16) & 0xFF) * 257;
+		temp.green = ((rgb >> 8) & 0xFF) * 257;
+		temp.blue = (rgb & 0xFF) * 257;
+		temp.flags = DoRed | DoGreen | DoBlue;
+		GetColor(&temp);
+	} else {
+		if(!GetColorByName(value, &temp)) {
+			Warning("bad color: \"%s\"", value);
+			return 0;
+		}
+	}
+	colors[type] = temp.pixel;
+	rgbColors[type] = GetRGBFromXColor(&temp);
+
+	return 1;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetDefaultColor(ColorType type) {
+
+	int x;
+
+	for(x = 0; DEFAULT_COLORS[x].value; x++) {
+		if(DEFAULT_COLORS[x].type == type) {
+			ParseColor(type, DEFAULT_COLORS[x].value);
+			return;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeNames() {
+
+	int x;
+
+	if(names == NULL) {
+		names = Allocate(sizeof(char*) * COLOR_COUNT);
+		for(x = 0; x < COLOR_COUNT; x++) {
+			names[x] = NULL;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+unsigned long ReadHex(const char *hex) {
+
+	unsigned long value = 0;
+	int x;
+
+	Assert(hex);
+
+	for(x = 0; hex[x]; x++) {
+		value *= 16;
+		if(hex[x] >= '0' && hex[x] <= '9') {
+			value += hex[x] - '0';
+		} else if(hex[x] >= 'A' && hex[x] <= 'F') {
+			value += hex[x] - 'A' + 10;
+		} else if(hex[x] >= 'a' && hex[x] <= 'f') {
+			value += hex[x] - 'a' + 10;
+		}
+	}
+
+	return value;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void LightenColor(ColorType oldColor, ColorType newColor) {
+
+	XColor temp;
+	float red, green, blue;
+	float delta = 1.0 + COLOR_DELTA;
+
+	temp = GetXColorFromRGB(rgbColors[oldColor]);
+
+	red = (float)temp.red / 65535.0;
+	green = (float)temp.green / 65535.0;
+	blue = (float)temp.blue / 65535.0;
+
+	red = Min(delta * red, 1.0);
+	green = Min(delta * green, 1.0);
+	blue = Min(delta * blue, 1.0);
+
+	temp.red = red * 65535.0;
+	temp.green = green * 65535.0;
+	temp.blue = blue * 65535.0;
+
+	GetColor(&temp);
+	colors[newColor] = temp.pixel;
+	rgbColors[newColor] = GetRGBFromXColor(&temp);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DarkenColor(ColorType oldColor, ColorType newColor) {
+
+	XColor temp;
+	float red, green, blue;
+	float delta = 1.0 - COLOR_DELTA;
+
+	temp = GetXColorFromRGB(rgbColors[oldColor]);
+
+	red = (float)temp.red / 65535.0;
+	green = (float)temp.green / 65535.0;
+	blue = (float)temp.blue / 65535.0;
+
+	red = delta * red;
+	green = delta * green;
+	blue = delta * blue;
+
+	temp.red = red * 65535.0;
+	temp.green = green * 65535.0;
+	temp.blue = blue * 65535.0;
+
+	GetColor(&temp);
+	colors[newColor] = temp.pixel;
+	rgbColors[newColor] = GetRGBFromXColor(&temp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int GetColorByName(const char *str, XColor *c) {
+
+	Assert(str);
+	Assert(c);
+
+	if(!JXParseColor(display, rootColormap, str, c)) {
+		return 0;
+	}
+
+	GetColor(c);
+
+	return 1;
+
+}
+
+/***************************************************************************
+ * Compute the RGB components from an index into our RGB colormap.
+ ***************************************************************************/
+void GetColorFromIndex(XColor *c) {
+
+	unsigned long red;
+	unsigned long green;
+	unsigned long blue;
+
+	Assert(c);
+
+	red = (c->pixel & redMask) << redShift;
+	green = (c->pixel & greenMask) << greenShift;
+	blue = (c->pixel & blueMask) << blueShift;
+
+	c->red = red >> 16;
+	c->green = green >> 16;
+	c->blue = blue >> 16;
+
+}
+
+/***************************************************************************
+ * Compute the pixel value from RGB components.
+ ***************************************************************************/
+void GetDirectPixel(XColor *c) {
+
+	unsigned long red;
+	unsigned long green;
+	unsigned long blue;
+
+	Assert(c);
+
+	/* Normalize. */
+	red = c->red << 16;
+	green = c->green << 16;
+	blue = c->blue << 16;
+
+	/* Shift to the correct offsets and mask. */
+	red = (red >> redShift) & redMask;
+	green = (green >> greenShift) & greenMask;
+	blue = (blue >> blueShift) & blueMask;
+
+	/* Combine. */
+	c->pixel = red | green | blue;
+
+}
+
+/***************************************************************************
+ * Compute the pixel value from RGB components.
+ ***************************************************************************/
+void GetMappedPixel(XColor *c) {
+
+	Assert(c);
+
+	GetDirectPixel(c);
+	c->pixel = map[c->pixel];
+
+}
+
+/***************************************************************************
+ * Compute the pixel value from RGB components.
+ ***************************************************************************/
+void GetColor(XColor *c) {
+
+	Assert(c);
+	Assert(rootVisual);
+
+	switch(rootVisual->class) {
+	case DirectColor:
+	case TrueColor:
+		GetDirectPixel(c);
+		return;
+	default:
+		GetMappedPixel(c);
+		return;
+	}
+
+}
+
+/***************************************************************************
+ * When loading images from external sources, we need to know the color
+ * components even if running with a colormap. So here we pretend
+ * we have a linear RGB colormap even if we don't.
+ * This prevents calls to XQueryColor later.
+ ***************************************************************************/
+void GetColorIndex(XColor *c) {
+
+	Assert(c);
+
+	GetDirectPixel(c);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+#ifdef USE_XFT
+XftColor *GetXftColor(ColorType type) {
+
+	unsigned long rgb;
+	XRenderColor rcolor;
+
+	if(!xftColors[type]) {
+		rgb = rgbColors[type];
+		xftColors[type] = Allocate(sizeof(XftColor));
+		rcolor.alpha = 65535;
+		rcolor.red = ((rgb >> 16) & 0xFF) * 257;
+		rcolor.green = ((rgb >> 8) & 0xFF) * 257;
+		rcolor.blue = (rgb & 0xFF) * 257;
+		JXftColorAllocValue(display, rootVisual, rootColormap, &rcolor,
+			xftColors[type]);
+	}
+
+	return xftColors[type];
+
+}
+#endif
+
diff --git a/src/color.h b/src/color.h
new file mode 100644
index 0000000..6e9ba60
--- /dev/null
+++ b/src/color.h
@@ -0,0 +1,91 @@
+/**
+ * @file color.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the color functions.
+ *
+ */
+
+#ifndef COLOR_H
+#define COLOR_H
+
+typedef enum {
+
+	COLOR_BORDER_BG,
+	COLOR_BORDER_FG,
+	COLOR_BORDER_ACTIVE_BG,
+	COLOR_BORDER_ACTIVE_FG,
+
+	COLOR_TRAY_BG,
+	COLOR_TRAY_FG,
+
+	COLOR_TASK_BG,
+	COLOR_TASK_FG,
+	COLOR_TASK_ACTIVE_BG,
+	COLOR_TASK_ACTIVE_FG,
+
+	COLOR_PAGER_BG,
+	COLOR_PAGER_FG,
+	COLOR_PAGER_ACTIVE_BG,
+	COLOR_PAGER_ACTIVE_FG,
+	COLOR_PAGER_OUTLINE,
+
+	COLOR_MENU_BG,
+	COLOR_MENU_FG,
+	COLOR_MENU_ACTIVE_BG,
+	COLOR_MENU_ACTIVE_FG,
+
+	COLOR_BORDER_UP,
+	COLOR_BORDER_DOWN,
+	COLOR_BORDER_ACTIVE_UP,
+	COLOR_BORDER_ACTIVE_DOWN,
+
+	COLOR_TRAY_UP,
+	COLOR_TRAY_DOWN,
+
+	COLOR_TASK_UP,
+	COLOR_TASK_DOWN,
+	COLOR_TASK_ACTIVE_UP,
+	COLOR_TASK_ACTIVE_DOWN,
+
+	COLOR_MENU_UP,
+	COLOR_MENU_DOWN,
+	COLOR_MENU_ACTIVE_UP,
+	COLOR_MENU_ACTIVE_DOWN,
+
+	COLOR_POPUP_BG,
+	COLOR_POPUP_FG,
+	COLOR_POPUP_OUTLINE,
+
+	COLOR_TRAYBUTTON_BG,
+	COLOR_TRAYBUTTON_FG,
+
+	COLOR_CLOCK_BG,
+	COLOR_CLOCK_FG,
+
+	COLOR_COUNT
+
+} ColorType;
+
+extern unsigned long colors[COLOR_COUNT];
+
+/*@{*/
+void InitializeColors();
+void StartupColors();
+void ShutdownColors();
+void DestroyColors();
+/*@}*/
+
+void SetColor(ColorType c, const char *value);
+
+void GetColor(XColor *c);
+void GetColorIndex(XColor *c);
+void GetColorFromIndex(XColor *c);
+
+#ifdef USE_XFT
+XftColor *GetXftColor(ColorType type);
+#endif
+
+#endif
+
diff --git a/src/command.c b/src/command.c
new file mode 100644
index 0000000..b82498d
--- /dev/null
+++ b/src/command.c
@@ -0,0 +1,124 @@
+/**
+ * @file command.c
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Handle running startup, shutdown, and restart commands.
+ *
+ */
+
+#include "jwm.h"
+#include "command.h"
+#include "root.h"
+#include "misc.h"
+#include "main.h"
+
+/** Structure to represent a list of commands. */
+typedef struct CommandNode {
+	char *command;             /**< The command. */
+	struct CommandNode *next;  /**< The next command in the list. */
+} CommandNode;
+
+static CommandNode *startupCommands;
+static CommandNode *shutdownCommands;
+static CommandNode *restartCommands;
+
+static void RunCommands(CommandNode *commands);
+static void ReleaseCommands(CommandNode **commands);
+static void AddCommand(CommandNode **commands, const char *command);
+
+/** Initialize the command lists. */
+void InitializeCommands() {
+	startupCommands = NULL;
+	shutdownCommands = NULL;
+	restartCommands = NULL;
+}
+
+/** Process startup/restart commands. */
+void StartupCommands() {
+
+	if(isRestarting) {
+		RunCommands(restartCommands);
+	} else {
+		RunCommands(startupCommands);
+	}
+
+}
+
+/** Process shutdown commands. */
+void ShutdownCommands() {
+
+	if(!shouldRestart) {
+		RunCommands(shutdownCommands);
+	}
+
+}
+
+/** Destroy the command lists. */
+void DestroyCommands() {
+	ReleaseCommands(&startupCommands);
+	ReleaseCommands(&shutdownCommands);
+	ReleaseCommands(&restartCommands);
+}
+
+/** Run the commands in a command list. */
+void RunCommands(CommandNode *commands) {
+
+	CommandNode *cp;
+
+	for(cp = commands; cp; cp = cp->next) {
+		RunCommand(cp->command);
+	}
+
+}
+
+/** Release a command list. */
+void ReleaseCommands(CommandNode **commands) {
+
+	CommandNode *cp;
+
+	Assert(commands);
+
+	while(*commands) {
+		cp = (*commands)->next;
+		Release((*commands)->command);
+		Release(*commands);
+		*commands = cp;
+	}
+
+}
+
+/** Add a command to a command list. */
+void AddCommand(CommandNode **commands, const char *command) {
+
+	CommandNode *cp;
+
+	Assert(commands);
+
+	if(!command) {
+		return;
+	}
+
+	cp = Allocate(sizeof(CommandNode));
+	cp->next = *commands;
+	*commands = cp;
+
+	cp->command = CopyString(command);
+
+}
+
+/** Add a startup command. */
+void AddStartupCommand(const char *command) {
+	AddCommand(&startupCommands, command);
+}
+
+/** Add a shutdown command. */
+void AddShutdownCommand(const char *command) {
+	AddCommand(&shutdownCommands, command);
+}
+
+/** Add a restart command. */
+void AddRestartCommand(const char *command) {
+	AddCommand(&restartCommands, command);
+}
+
diff --git a/src/command.h b/src/command.h
new file mode 100644
index 0000000..7c05e05
--- /dev/null
+++ b/src/command.h
@@ -0,0 +1,36 @@
+/**
+ * @file command.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Handle running startup, shutdown, and restart commands.
+ *
+ */
+
+#ifndef COMMAND_H
+#define COMMAND_H
+
+/*@{*/
+void InitializeCommands();
+void StartupCommands();
+void ShutdownCommands();
+void DestroyCommands();
+/*@}*/
+
+/** Add a command to be executed at startup.
+ * @param command The command to execute.
+ */
+void AddStartupCommand(const char *command);
+
+/** Add a command to be executed at shutdown.
+ * @param command The command to execute.
+ */
+void AddShutdownCommand(const char *command);
+
+/** Add a command to be executed after a restart.
+ * @param command The command to execute.
+ */
+void AddRestartCommand(const char *command);
+
+#endif
+
diff --git a/src/confirm.c b/src/confirm.c
new file mode 100644
index 0000000..77aa48e
--- /dev/null
+++ b/src/confirm.c
@@ -0,0 +1,412 @@
+/**
+ * @file confirm.c
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Confirm dialog functions.
+ *
+ */
+
+#include "jwm.h"
+#include "confirm.h"
+#include "client.h"
+#include "main.h"
+#include "font.h"
+#include "button.h"
+#include "screen.h"
+#include "color.h"
+#include "misc.h"
+
+#ifndef DISABLE_CONFIRM
+
+typedef struct DialogType {
+
+	int x, y;
+	int width, height;
+	int lineHeight;
+
+	int okx;
+	int cancelx;
+	int buttony;
+	int buttonWidth, buttonHeight;
+
+	int lineCount;
+	char **message;
+
+	ClientNode *node;
+
+	void (*action)(ClientNode*);
+	ClientNode *client;
+
+	struct DialogType *prev;
+	struct DialogType *next;
+
+} DialogType;
+
+static const char *OK_STRING = "Ok";
+static const char *CANCEL_STRING = "Cancel";
+
+static DialogType *dialogList = NULL;
+
+static int minWidth = 0;
+
+static void DrawConfirmDialog(DialogType *d);
+static void DestroyConfirmDialog(DialogType *d);
+static void ComputeDimensions(DialogType *d);
+static void DrawMessage(DialogType *d);
+static void DrawButtons(DialogType *d);
+static DialogType *FindDialogByWindow(Window w);
+static int HandleDialogExpose(const XExposeEvent *event); 
+static int HandleDialogButtonRelease(const XButtonEvent *event);
+
+/** Initialize the dialog processing data. */
+void InitializeDialogs() {
+}
+
+/** Startup dialog processing. */
+void StartupDialogs() {
+}
+
+/** Stop dialog processing. */
+void ShutdownDialogs() {
+
+	while(dialogList) {
+		DestroyConfirmDialog(dialogList);
+	}
+
+}
+
+/** Destroy dialog processing data. */
+void DestroyDialogs() {
+}
+
+/** Handle an event on a dialog window. */
+int ProcessDialogEvent(const XEvent *event) {
+
+	int handled = 0;
+
+	Assert(event);
+
+	switch(event->type) {
+	case Expose:
+		return HandleDialogExpose(&event->xexpose);
+	case ButtonRelease:
+		return HandleDialogButtonRelease(&event->xbutton);
+	default:
+		break;
+	}
+
+	return handled;
+
+}
+
+/** Handle an expose event. */
+int HandleDialogExpose(const XExposeEvent *event) {
+
+	DialogType *dp;
+
+	Assert(event);
+
+	dp = FindDialogByWindow(event->window);
+	if(dp) {
+		DrawConfirmDialog(dp);
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+/** Handle a mouse button release event. */
+int HandleDialogButtonRelease(const XButtonEvent *event) {
+
+	DialogType *dp;
+	int x, y;
+	int cancelPressed, okPressed;
+
+	Assert(event);
+
+	dp = FindDialogByWindow(event->window);
+	if(dp) {
+		cancelPressed = 0;
+		okPressed = 0;
+		y = event->y;
+		if(y >= dp->buttony && y < dp->buttony + dp->buttonHeight) {
+			x = event->x;
+			if(x >= dp->okx && x < dp->okx + dp->buttonWidth) {
+				okPressed = 1;
+			} else if(x >= dp->cancelx && x < dp->cancelx + dp->buttonWidth) {
+				cancelPressed = 1;
+			}
+		}
+
+		if(okPressed) {
+			(dp->action)(dp->client);
+		}
+
+		if(cancelPressed || okPressed) {
+			DestroyConfirmDialog(dp);
+		}
+
+		return 1;
+	} else {
+		return 0;
+	}
+
+}
+
+/** Find a dialog by window or frame. */
+DialogType *FindDialogByWindow(Window w) {
+
+	DialogType *dp;
+
+	for(dp = dialogList; dp; dp = dp->next) {
+		if(dp->node->window == w || dp->node->parent == w) {
+			return dp;
+		}
+	}
+
+	return NULL;
+
+}
+
+/** Show a confirm dialog. */
+void ShowConfirmDialog(ClientNode *np, void (*action)(ClientNode*), ...) {
+
+	va_list ap;
+	DialogType *dp;
+	XSetWindowAttributes attrs;
+	XSizeHints shints;
+	Window window;
+	char *str;
+	int x;
+
+	Assert(action);
+
+	dp = Allocate(sizeof(DialogType));
+	dp->client = np;
+	dp->action = action;
+
+	dp->prev = NULL;
+	dp->next = dialogList;
+	if(dialogList) {
+		dialogList->prev = dp;
+	}
+	dialogList = dp;
+
+	/* Get the number of lines. */
+	va_start(ap, action);
+	for(dp->lineCount = 0; va_arg(ap, char*); dp->lineCount++);
+	va_end(ap);
+
+	dp->message = Allocate(dp->lineCount * sizeof(char*));
+	va_start(ap, action);
+	for(x = 0; x < dp->lineCount; x++) {
+		str = va_arg(ap, char*);
+		dp->message[x] = CopyString(str);
+	}
+	va_end(ap);
+
+	ComputeDimensions(dp);
+
+	attrs.background_pixel = colors[COLOR_MENU_BG];
+	attrs.event_mask = ButtonReleaseMask | ExposureMask;
+
+	window = JXCreateWindow(display, rootWindow,
+		dp->x, dp->y, dp->width, dp->height, 0,
+		CopyFromParent, InputOutput, CopyFromParent,
+		CWBackPixel | CWEventMask, &attrs);
+
+	shints.x = dp->x;
+	shints.y = dp->y;
+	shints.flags = PPosition;
+	JXSetWMNormalHints(display, window, &shints);
+
+	JXStoreName(display, window, "Confirm");
+
+	dp->node = AddClientWindow(window, 0, 0);
+	Assert(dp->node);
+	if(np) {
+		dp->node->owner = np->window;
+	}
+	dp->node->state.status |= STAT_WMDIALOG;
+	FocusClient(dp->node);
+
+	DrawConfirmDialog(dp);
+
+	JXGrabButton(display, AnyButton, AnyModifier, window,
+		True, ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None);
+
+}
+
+/** Draw a confirm dialog. */
+void DrawConfirmDialog(DialogType *dp) {
+
+	Assert(dp);
+
+	DrawMessage(dp);
+	DrawButtons(dp);
+
+}
+
+/** Destroy a confirm dialog. */
+void DestroyConfirmDialog(DialogType *dp) {
+
+	int x;
+
+	Assert(dp);
+
+	/* This will take care of destroying the dialog window since
+	 * its parent will be destroyed. */
+	RemoveClient(dp->node);
+
+	for(x = 0; x < dp->lineCount; x++) {
+		Release(dp->message[x]);
+	}
+	Release(dp->message);
+
+	if(dp->next) {
+		dp->next->prev = dp->prev;
+	}
+	if(dp->prev) {
+		dp->prev->next = dp->next;
+	} else {
+		dialogList = dp->next;
+	}
+	Release(dp);
+
+}
+
+/** Compute the size of a dialog window. */
+void ComputeDimensions(DialogType *dp) {
+
+	const ScreenType *sp;
+	int width;
+	int x;
+
+	Assert(dp);
+
+	if(!minWidth) {
+		minWidth = GetStringWidth(FONT_MENU, CANCEL_STRING) * 3;
+		width = GetStringWidth(FONT_MENU, OK_STRING) * 3;
+		if(width > minWidth) {
+			minWidth = width;
+		}
+		minWidth += 30;
+	}
+	dp->width = minWidth;
+
+	for(x = 0; x < dp->lineCount; x++) {
+		width = GetStringWidth(FONT_MENU, dp->message[x]);
+		if(width > dp->width) {
+			dp->width = width;
+		}
+	}
+	dp->lineHeight = GetStringHeight(FONT_MENU);
+	dp->width += 8;
+	dp->height = (dp->lineCount + 2) * dp->lineHeight;
+
+	if(dp->client) {
+
+		dp->x = dp->client->x + dp->client->width / 2 - dp->width / 2;
+		dp->y = dp->client->y + dp->client->height / 2 - dp->height / 2;
+
+		if(dp->x < 0) {
+			dp->x = 0;
+		}
+		if(dp->y < 0) {
+			dp->y = 0;
+		}
+		if(dp->x + dp->width >= rootWidth) {
+			dp->x = rootWidth - dp->width - (borderWidth * 2);
+		}
+		if(dp->y + dp->height >= rootHeight) {
+			dp->y = rootHeight - dp->height - (borderWidth * 2 + titleHeight);
+		}
+
+	} else {
+
+		sp = GetMouseScreen();
+
+		dp->x = sp->width / 2 - dp->width / 2 + sp->x;
+		dp->y = sp->height / 2 - dp->height / 2 + sp->y;
+
+	}
+
+}
+
+/** Display the message on the dialog window. */
+void DrawMessage(DialogType *dp) {
+
+	int yoffset;
+	int x;
+
+	Assert(dp);
+
+	yoffset = 4;
+	for(x = 0; x < dp->lineCount; x++) {
+		RenderString(dp->node->window, FONT_MENU, COLOR_MENU_FG,
+			4, yoffset, dp->width, NULL, dp->message[x]);
+		yoffset += dp->lineHeight;
+	}
+
+}
+
+/** Draw the buttons on the dialog window. */
+void DrawButtons(DialogType *dp) {
+
+	ButtonNode button;
+	int temp;
+
+	Assert(dp);
+
+	dp->buttonWidth = GetStringWidth(FONT_MENU, CANCEL_STRING);
+	temp = GetStringWidth(FONT_MENU, OK_STRING);
+	if(temp > dp->buttonWidth) {
+		dp->buttonWidth = temp;
+	}
+	dp->buttonWidth += 8;
+	dp->buttonHeight = dp->lineHeight + 4;
+
+	ResetButton(&button, dp->node->window, rootGC);
+	button.font = FONT_MENU;
+	button.width = dp->buttonWidth;
+	button.height = dp->buttonHeight;
+	button.alignment = ALIGN_CENTER;
+
+	dp->okx = dp->width / 3 - dp->buttonWidth / 2;
+	dp->cancelx = 2 * dp->width / 3 - dp->buttonWidth / 2;
+	dp->buttony = dp->height - dp->lineHeight - dp->lineHeight / 2;
+
+	button.type = BUTTON_MENU;
+	button.text = OK_STRING;
+	button.x = dp->okx;
+	button.y = dp->buttony;
+	DrawButton(&button);
+
+	button.text = CANCEL_STRING;
+	button.x = dp->cancelx;
+	button.y = dp->buttony;
+	DrawButton(&button);
+
+}
+
+#else /* DISABLE_CONFIRM */
+
+/** Process an event on a dialog window. */
+int ProcessDialogEvent(const XEvent *event) {
+	return 0;
+}
+
+/** Show a confirm dialog. */
+void ShowConfirmDialog(ClientNode *np, void (*action)(ClientNode*), ...) {
+
+	Assert(action);
+
+	(action)(np);
+
+}
+
+#endif /* DISABLE_CONFIRM */
+
+
+
diff --git a/src/confirm.h b/src/confirm.h
new file mode 100644
index 0000000..21161f2
--- /dev/null
+++ b/src/confirm.h
@@ -0,0 +1,36 @@
+/**
+ * @file confirm.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the confirm dialog functions.
+ *
+ */
+
+#ifndef CONFIRM_H
+#define CONFIRM_H
+
+struct ClientNode;
+
+/*@{*/
+void InitializeDialogs();
+void StartupDialogs();
+void ShutdownDialogs();
+void DestroyDialogs();
+/*@}*/
+
+/** Handle an event on a dialog window.
+ * @param event The event.
+ * @return 1 if handled, 0 if not handled.
+ */
+int ProcessDialogEvent(const XEvent *event);
+
+/** Show a confirm dialog.
+ * @param np A client window associated with the dialog.
+ * @param action A callback to run if "OK" is clicked.
+ */
+void ShowConfirmDialog(struct ClientNode *np,
+	void (*action)(struct ClientNode*), ...);
+
+#endif
+
diff --git a/src/cursor.c b/src/cursor.c
new file mode 100644
index 0000000..b4a6ca7
--- /dev/null
+++ b/src/cursor.c
@@ -0,0 +1,313 @@
+/****************************************************************************
+ * Functions to handle the mouse cursor.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "cursor.h"
+#include "main.h"
+#include "error.h"
+
+static Cursor defaultCursor;
+static Cursor moveCursor;
+static Cursor northCursor;
+static Cursor southCursor;
+static Cursor eastCursor;
+static Cursor westCursor;
+static Cursor northEastCursor;
+static Cursor northWestCursor;
+static Cursor southEastCursor;
+static Cursor southWestCursor;
+static Cursor chooseCursor;
+
+static Cursor GetResizeCursor(BorderActionType action);
+static Cursor CreateCursor(unsigned int shape);
+
+static int mousex;
+static int mousey;
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeCursors() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupCursors() {
+
+	Window win1, win2;
+	int winx, winy;
+	unsigned int mask;
+
+	defaultCursor = CreateCursor(XC_left_ptr);
+	moveCursor = CreateCursor(XC_fleur);
+	northCursor = CreateCursor(XC_top_side);
+	southCursor = CreateCursor(XC_bottom_side);
+	eastCursor = CreateCursor(XC_right_side);
+	westCursor = CreateCursor(XC_left_side);
+	northEastCursor = CreateCursor(XC_ur_angle);
+	northWestCursor = CreateCursor(XC_ul_angle);
+	southEastCursor = CreateCursor(XC_lr_angle);
+	southWestCursor = CreateCursor(XC_ll_angle);
+	chooseCursor = CreateCursor(XC_tcross);
+
+	JXQueryPointer(display, rootWindow, &win1, &win2,
+		&mousex, &mousey, &winx, &winy, &mask);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+Cursor CreateCursor(unsigned int shape) {
+	return JXCreateFontCursor(display, shape);
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownCursors() {
+
+	JXFreeCursor(display, defaultCursor);
+	JXFreeCursor(display, moveCursor);
+	JXFreeCursor(display, northCursor);
+	JXFreeCursor(display, southCursor);
+	JXFreeCursor(display, eastCursor);
+	JXFreeCursor(display, westCursor);
+	JXFreeCursor(display, northEastCursor);
+	JXFreeCursor(display, northWestCursor);
+	JXFreeCursor(display, southEastCursor);
+	JXFreeCursor(display, southWestCursor);
+	JXFreeCursor(display, chooseCursor);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyCursors() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+Cursor GetFrameCursor(BorderActionType action) {
+
+	switch(action & 0x0F) {
+	case BA_RESIZE:
+		return GetResizeCursor(action);
+	case BA_CLOSE:
+		break;
+	case BA_MAXIMIZE:
+		break;
+	case BA_MINIMIZE:
+		break;
+	case BA_MOVE:
+		break;
+	default:
+		break;
+	}
+	return defaultCursor;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+Cursor GetResizeCursor(BorderActionType action) {
+
+	if(action & BA_RESIZE_N) {
+		if(action & BA_RESIZE_E) {
+			return northEastCursor;
+		} else if(action & BA_RESIZE_W) {
+			return northWestCursor;
+		} else {
+			return northCursor;
+		}
+	} else if(action & BA_RESIZE_S) {
+		if(action & BA_RESIZE_E) {
+			return southEastCursor;
+		} else if(action & BA_RESIZE_W) {
+			return southWestCursor;
+		} else {
+			return southCursor;
+		}
+	} else {
+		if(action & BA_RESIZE_E) {
+			return eastCursor;
+		} else {
+			return westCursor;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GrabMouseForResize(BorderActionType action) {
+
+	Cursor cur;
+	int result;
+
+	cur = GetFrameCursor(action);
+
+	result = JXGrabPointer(display, rootWindow, False, ButtonPressMask
+		| ButtonReleaseMask | PointerMotionMask, GrabModeAsync,
+		GrabModeAsync, None, cur, CurrentTime);
+
+	if(result == GrabSuccess) {
+		return 1;
+	} else {
+		return 0;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GrabMouseForMove() {
+
+	int result;
+
+	result = JXGrabPointer(display, rootWindow, False,
+		ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
+		GrabModeAsync, GrabModeAsync, None, moveCursor, CurrentTime);
+
+	if(result == GrabSuccess) {
+
+		return 1;
+
+	} else {
+
+		return 0;
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GrabMouseForMenu() {
+
+	int result;
+
+	result = JXGrabPointer(display, rootWindow, False,
+		ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
+		GrabModeAsync, GrabModeAsync, None, defaultCursor, CurrentTime);
+
+	if(result == GrabSuccess) {
+		return 1;
+	} else {
+		return 0;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GrabMouseForChoose() {
+
+	int result;
+
+	result = JXGrabPointer(display, rootWindow, False,
+		ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
+		GrabModeAsync, GrabModeAsync, None, chooseCursor, CurrentTime);
+
+	if(result == GrabSuccess) {
+		return 1;
+	} else {
+		return 0;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetDefaultCursor(Window w) {
+
+	JXDefineCursor(display, w, defaultCursor);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void MoveMouse(Window win, int x, int y) {
+
+	Window win1, win2;
+	int winx, winy;
+	unsigned int mask;
+
+	JXWarpPointer(display, None, win, 0, 0, 0, 0, x, y);
+
+	JXQueryPointer(display, rootWindow, &win1, &win2,
+		&mousex, &mousey, &winx, &winy, &mask);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetMousePosition(int x, int y) {
+
+	mousex = x;
+	mousey = y;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void GetMousePosition(int *x, int *y) {
+
+	Assert(x);
+	Assert(y);
+
+	*x = mousex;
+	*y = mousey;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+unsigned int GetMouseMask() {
+
+	Window win1, win2;
+	int winx, winy;
+	unsigned int mask;
+
+	JXQueryPointer(display, rootWindow, &win1, &win2,
+		&mousex, &mousey, &winx, &winy, &mask);
+
+	return mask;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetDoubleClickSpeed(const char *str) {
+
+	int speed;
+
+	if(str) {
+		speed = atoi(str);
+		if(speed < MIN_DOUBLE_CLICK_SPEED || speed > MAX_DOUBLE_CLICK_SPEED) {
+			Warning("invalid DoubleClickSpeed: %d", speed);
+			doubleClickSpeed = DEFAULT_DOUBLE_CLICK_SPEED;
+		} else {
+			doubleClickSpeed = speed;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetDoubleClickDelta(const char *str) {
+
+	int delta;
+
+	if(str) {
+		delta = atoi(str);
+		if(delta < MIN_DOUBLE_CLICK_DELTA || delta > MAX_DOUBLE_CLICK_DELTA) {
+			Warning("invalid DoubleClickDelta: %d", delta);
+			doubleClickDelta = DEFAULT_DOUBLE_CLICK_DELTA;
+		} else {
+			doubleClickDelta = delta;
+		}
+	}
+
+}
+
diff --git a/src/cursor.h b/src/cursor.h
new file mode 100644
index 0000000..b8b6868
--- /dev/null
+++ b/src/cursor.h
@@ -0,0 +1,44 @@
+/**
+ * @file confirm.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the cursor functions.
+ *
+ */
+
+#ifndef CURSOR_H
+#define CURSOR_H
+
+#include "border.h"
+
+/*@{*/
+void InitializeCursors();
+void StartupCursors();
+void ShutdownCursors();
+void DestroyCursors();
+/*@}*/
+
+int GrabMouseForResize(BorderActionType action);
+int GrabMouseForMove();
+
+int GrabMouseForMenu();
+int GrabMouseForChoose();
+
+Cursor GetFrameCursor(BorderActionType action);
+
+void MoveMouse(Window win, int x, int y);
+
+void SetMousePosition(int x, int y);
+void GetMousePosition(int *x, int *y);
+
+unsigned int GetMouseMask();
+
+void SetDefaultCursor(Window w);
+
+void SetDoubleClickSpeed(const char *str);
+void SetDoubleClickDelta(const char *str);
+
+#endif
+
+
diff --git a/src/debug.c b/src/debug.c
new file mode 100644
index 0000000..6527abd
--- /dev/null
+++ b/src/debug.c
@@ -0,0 +1,396 @@
+/***************************************************************************
+ * Debug functions.
+ * Copyright (C) 2003 Joe Wingbermuehle
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ ***************************************************************************/
+
+#include "debug.h"
+
+/***************************************************************************
+ * Emit a message.
+ ***************************************************************************/
+void Debug(const char *str, ...) {
+#ifdef DEBUG
+	va_list ap;
+	va_start(ap, str);
+
+	Assert(str);
+
+	fprintf(stderr, "DEBUG: ");
+	vfprintf(stderr, str, ap);
+	fprintf(stderr, "\n");
+
+	va_end(ap);
+#endif
+}
+
+#ifdef DEBUG
+
+#define CHECKPOINT_LIST_SIZE 8
+
+typedef struct MemoryType {
+	const char *file;
+	unsigned int line;
+	size_t size;
+	void *pointer;
+	struct MemoryType *next;
+} MemoryType;
+
+static MemoryType *allocations = NULL;
+
+typedef struct ResourceType {
+	int resource;
+	const char *allocationFiles[CHECKPOINT_LIST_SIZE];
+	unsigned int allocationLines[CHECKPOINT_LIST_SIZE];
+	const char *releaseFiles[CHECKPOINT_LIST_SIZE];
+	unsigned int releaseLines[CHECKPOINT_LIST_SIZE];
+	unsigned int allocationOffset;
+	unsigned int releaseOffset;
+	size_t count;
+	struct ResourceType *next;
+} ResourceType;
+
+static ResourceType *resources = NULL;
+
+static const char *checkpointFile[CHECKPOINT_LIST_SIZE];
+static unsigned int checkpointLine[CHECKPOINT_LIST_SIZE];
+static int checkpointOffset;
+
+static void DEBUG_PrintResourceStack(ResourceType *rp);
+
+/***************************************************************************
+ * Start the debugger.
+ ***************************************************************************/
+void DEBUG_StartDebug(const char *file, unsigned int line) {
+	int x;
+
+	Debug("%s[%u]: debug mode started", file, line);
+
+	checkpointOffset = 0;
+	for(x = 0; x < CHECKPOINT_LIST_SIZE; x++) {
+		checkpointFile[x] = NULL;
+		checkpointLine[x] = 0;
+	}
+
+}
+
+/***************************************************************************
+ * Stop the debugger.
+ ***************************************************************************/
+void DEBUG_StopDebug(const char *file, unsigned int line) {
+	MemoryType *mp;
+	ResourceType *rp;
+	unsigned int count = 0;
+
+	Debug("%s[%u]: debug mode stopped", file, line);
+
+	if(allocations) {
+		Debug("MEMORY: memory leaks follow");
+		for(mp = allocations; mp; mp = mp->next) {
+			Debug("        %u bytes in %s at line %u",
+				mp->size, mp->file, mp->line);
+			++count;
+		}
+		if(count == 1) {
+			Debug("MEMORY: 1 memory leak");
+		} else {
+			Debug("MEMORY: %u memory leaks", count);
+		}
+	} else {
+		Debug("MEMORY: no memory leaks");
+	}
+
+	if(resources) {
+		for(rp = resources; rp; rp = rp->next) {
+			if(rp->count > 0) {
+				Debug("RESOURCE: resource %d has reference count %u",
+					rp->resource, rp->count);
+				DEBUG_PrintResourceStack(rp);
+			}
+		}
+	}
+
+}
+
+/***************************************************************************
+ * Print the resource allocation/release stacks for a resource.
+ ***************************************************************************/
+void DEBUG_PrintResourceStack(ResourceType *rp) {
+	unsigned int x, offset;
+
+	Debug("          Allocation stack: (oldest)");
+	offset = rp->allocationOffset;
+	for(x = 0; x < CHECKPOINT_LIST_SIZE; x++) {
+		if(rp->allocationFiles[offset]) {
+			Debug("             %s line %u", rp->allocationFiles[offset],
+				rp->allocationLines[offset]);
+		}
+		offset = (offset + 1) % CHECKPOINT_LIST_SIZE;
+	}
+	Debug("          Release stack: (oldest)");
+	offset = rp->releaseOffset;
+	for(x = 0; x < CHECKPOINT_LIST_SIZE; x++) {
+		if(rp->releaseFiles[offset]) {
+			Debug("             %s line %u", rp->releaseFiles[offset],
+				rp->releaseLines[offset]);
+		}
+		offset = (offset + 1) % CHECKPOINT_LIST_SIZE;
+	}
+}
+
+/***************************************************************************
+ * Set a checkpoint.
+ ***************************************************************************/
+void DEBUG_SetCheckpoint(const char *file, unsigned int line) {
+
+	checkpointFile[checkpointOffset] = file;
+	checkpointLine[checkpointOffset] = line;
+
+	checkpointOffset = (checkpointOffset + 1) % CHECKPOINT_LIST_SIZE;
+
+}
+
+/***************************************************************************
+ * Display the location of the last checkpoint.
+ ***************************************************************************/
+void DEBUG_ShowCheckpoint() {
+	int x, offset;
+
+	Debug("CHECKPOINT LIST (oldest)");
+	offset = checkpointOffset;
+	for(x = 0; x < CHECKPOINT_LIST_SIZE; x++) {
+		if(checkpointFile[offset]) {
+			Debug("   %s[%u]", checkpointFile[offset], checkpointLine[offset]);
+		}
+		offset = (offset + 1) % CHECKPOINT_LIST_SIZE;
+	}
+	Debug("END OF CHECKPOINT LIST (most recent)");
+
+}
+
+/***************************************************************************
+ * Allocate memory and log.
+ ***************************************************************************/
+void *DEBUG_Allocate(size_t size, const char *file, unsigned int line) {
+	MemoryType *mp;
+
+	if(size <= 0) {
+		Debug("MEMORY: %s[%u]: Attempt to allocate %d bytes of memory",
+			file, line, size);
+	}
+
+	mp = (MemoryType*)malloc(sizeof(MemoryType));
+	Assert(mp);
+
+	mp->file = file;
+	mp->line = line;
+	mp->size = size;
+
+	mp->pointer = malloc(size + sizeof(char));
+	if(!mp->pointer) {
+		Debug("MEMORY: %s[%u]: Memory allocation failed (%d bytes)",
+			file, line, size);
+		Assert(0);
+	}
+
+	/* Make uninitialized accesses easy to find. */
+	memset(mp->pointer, 85, size);
+
+	/* Canary value for buffer overflow checking. */
+	((char*)mp->pointer)[size] = 42;
+
+	mp->next = allocations;
+	allocations = mp;
+
+	return mp->pointer;
+}
+
+/***************************************************************************
+ * Reallocate memory and log.
+ ***************************************************************************/
+void *DEBUG_Reallocate(void *ptr, size_t size, const char *file,
+	unsigned int line) {
+
+	MemoryType *mp;
+
+	if(size <= 0) {
+		Debug("MEMORY: %s[%u]: Attempt to reallocate %d bytes of memory",
+			file, line, size);
+	}
+	if(!ptr) {
+		Debug("MEMORY: %s[%u]: Attempt to reallocate NULL pointer. "
+			"Calling Allocate...", file, line);
+		return DEBUG_Allocate(size, file, line);
+	} else {
+
+		for(mp = allocations; mp; mp = mp->next) {
+			if(mp->pointer == ptr) {
+
+				if(((char*)ptr)[mp->size] != 42) {
+					Debug("MEMORY: %s[%u]: The canary is dead.", file, line);
+				}
+
+				mp->file = file;
+				mp->line = line;
+				mp->size = size;
+				mp->pointer = realloc(ptr, size + sizeof(char));
+				if(!mp->pointer) {
+					Debug("MEMORY: %s[%u]: Failed to reallocate %d bytes.",
+						file, line, size);
+					Assert(0);
+				}
+				((char*)mp->pointer)[size] = 42;
+				return mp->pointer;
+			}
+		}
+
+		Debug("MEMORY: %s[%u]: Attempt to reallocate unallocated pointer",
+			file, line);
+		mp = malloc(sizeof(MemoryType));
+		Assert(mp);
+		mp->file = file;
+		mp->line = line;
+		mp->size = size;
+		mp->pointer = malloc(size + sizeof(char));
+		if(!mp->pointer) {
+			Debug("MEMORY: %s[%u]: Failed to reallocate %d bytes.",
+				file, line, size);
+			Assert(0);
+		}
+		memset(mp->pointer, 85, size);
+		((char*)mp->pointer)[size] = 42;
+
+		mp->next = allocations;
+		allocations = mp;
+
+		return mp->pointer;
+	}
+
+}
+
+/***************************************************************************
+ * Release memory and log.
+ ***************************************************************************/
+void DEBUG_Release(void **ptr, const char *file, unsigned int line) {
+	MemoryType *mp, *last;
+
+	if(!ptr) {
+		Debug("MEMORY: %s[%u]: Invalid attempt to release", file, line);
+	} else if(!*ptr) {
+		Debug("MEMORY: %s[%u]: Attempt to delete NULL pointer",
+			file, line);
+	} else {
+		last = NULL;
+		for(mp = allocations; mp; mp = mp->next) {
+			if(mp->pointer == *ptr) {
+				if(last) {
+					last->next = mp->next;
+				} else {
+					allocations = mp->next;
+				}
+
+				if(((char*)*ptr)[mp->size] != 42) {
+					Debug("MEMORY: %s[%u]: The canary is dead.", file, line);
+				}
+
+				memset(*ptr, 0xFF, mp->size);
+				free(mp);
+				free(*ptr);
+				*ptr = NULL;
+				return;
+			}
+			last = mp;
+		}
+		Debug("MEMORY: %s[%u]: Attempt to delete unallocated pointer",
+			file, line);
+		memset(*ptr, 0xFF, mp->size);
+		free(*ptr);
+
+		/* This address should cause a segfault or bus error. */
+		*ptr = (void*)1;
+
+	}
+}
+
+/***************************************************************************
+ * Add a resource.
+ ***************************************************************************/
+void DEBUG_AllocateResource(int resource, const char *file,
+	unsigned int line) {
+
+	ResourceType *rp;
+
+	for(rp = resources; rp; rp = rp->next) {
+		if(rp->resource == resource) {
+
+			rp->allocationFiles[rp->allocationOffset] = file;
+			rp->allocationLines[rp->allocationOffset] = line;
+			rp->allocationOffset
+				= (rp->allocationOffset + 1) % CHECKPOINT_LIST_SIZE;
+
+			++rp->count;
+			return;
+		}
+	}
+
+	rp = malloc(sizeof(ResourceType));
+	memset(rp, 0, sizeof(ResourceType));
+	rp->resource = resource;
+	rp->allocationFiles[0] = file;
+	rp->allocationLines[0] = line;
+	rp->allocationOffset = 1;
+	rp->releaseOffset = 0;
+	rp->count = 1;
+
+	rp->next = resources;
+	resources = rp;
+
+}
+
+/***************************************************************************
+ * Remove a resource.
+ ***************************************************************************/
+void DEBUG_ReleaseResource(int resource, const char *file,
+	unsigned int line) {
+
+	ResourceType *rp;
+
+	for(rp = resources; rp; rp = rp->next) {
+		if(rp->resource == resource) {
+			rp->releaseFiles[rp->releaseOffset] = file;
+			rp->releaseLines[rp->releaseOffset] = line;
+			rp->releaseOffset = (rp->releaseOffset + 1) % CHECKPOINT_LIST_SIZE;
+			if(rp->count <= 0) {
+				Debug("RESOURCE: Multiple attempts to release resource %d",
+					resource);
+				DEBUG_PrintResourceStack(rp);
+			} else {
+				--rp->count;
+			}
+			return;
+		}
+	}
+
+	Debug("RESOURCE: Attempt to release unallocated resource %d",
+		resource);
+	Debug("          in %s at line %u", file, line);
+
+}
+
+#undef CHECKPOINT_LIST_SIZE
+
+#endif
+
diff --git a/src/debug.h b/src/debug.h
new file mode 100644
index 0000000..c74f1a8
--- /dev/null
+++ b/src/debug.h
@@ -0,0 +1,104 @@
+/**
+ * @file debug.h
+ * @author Joe Wingbermuehle
+ * @date 2003-2006
+ *
+ * @brief Header for the debug functions.
+ *
+ */
+
+/*
+ * 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef DEBUG_H
+#define DEBUG_H
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_ALLOCA_H
+#	include <alloca.h>
+#endif
+
+void Debug(const char *str, ...);
+
+#ifdef HAVE_ALLOCA_H
+
+#	define AllocateStack( x ) alloca( x )
+#	define ReleaseStack( x ) ((void)0)
+
+#else
+
+#	define AllocateStack( x ) Allocate( x )
+#	define ReleaseStack( x ) Release( x )
+
+#endif
+
+#ifdef DEBUG
+
+#	define Assert( x ) \
+		if(!( x )) {     \
+			Debug("ASSERT FAILED: %s[%u]", __FILE__, __LINE__ ); \
+			abort(); \
+		}
+
+#	define SetCheckpoint() \
+		DEBUG_SetCheckpoint( __FILE__, __LINE__ )
+#	define ShowCheckpoint() \
+		DEBUG_ShowCheckpoint()
+
+#	define StartDebug() \
+		DEBUG_StartDebug( __FILE__, __LINE__ )
+#	define StopDebug() \
+		DEBUG_StopDebug( __FILE__, __LINE__ )
+
+#	define Allocate( x ) \
+		DEBUG_Allocate( (x), __FILE__, __LINE__ )
+#	define Reallocate( x, y ) \
+		DEBUG_Reallocate( (x), (y), __FILE__, __LINE__ )
+#	define Release( x ) \
+		DEBUG_Release( (void*)(& x), __FILE__, __LINE__ )
+
+	void DEBUG_SetCheckpoint(const char*, unsigned int);
+	void DEBUG_ShowCheckpoint();
+
+	void DEBUG_StartDebug(const char*, unsigned int);
+	void DEBUG_StopDebug(const char*, unsigned int);
+
+	void *DEBUG_Allocate(size_t, const char*, unsigned int);
+	void *DEBUG_Reallocate(void*, size_t, const char*, unsigned int);
+	void DEBUG_Release(void**, const char*, unsigned int);
+
+#else
+
+#	define Assert( x )           ((void)0)
+
+#	define SetCheckpoint()       ((void)0)
+#	define ShowCheckpoint()      ((void)0)
+
+#	define StartDebug()          ((void)0)
+#	define StopDebug()           ((void)0)
+
+#	define Allocate( x )         malloc( (x) )
+#	define Reallocate( x, y )    realloc( (x), (y) )
+#	define Release( x )          free( (x) )
+
+#endif
+
+#endif
+
diff --git a/src/desktop.c b/src/desktop.c
new file mode 100644
index 0000000..1d09050
--- /dev/null
+++ b/src/desktop.c
@@ -0,0 +1,239 @@
+/***************************************************************************
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "desktop.h"
+#include "main.h"
+#include "client.h"
+#include "hint.h"
+#include "pager.h"
+#include "taskbar.h"
+#include "error.h"
+#include "menu.h"
+#include "misc.h"
+
+char **desktopNames = NULL;
+
+static int showingDesktop;
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeDesktops() {
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void StartupDesktops() {
+
+	unsigned int x;
+
+	if(desktopNames == NULL) {
+		desktopNames = Allocate(desktopCount * sizeof(char*));
+		for(x = 0; x < desktopCount; x++) {
+			desktopNames[x] = NULL;
+		}
+	}
+	for(x = 0; x < desktopCount; x++) {
+		if(desktopNames[x] == NULL) {
+			desktopNames[x] = Allocate(4 * sizeof(char));
+			snprintf(desktopNames[x], 4, "%d", x + 1);
+		}
+	}
+
+	showingDesktop = 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShutdownDesktops() {
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyDesktops() {
+
+	unsigned int x;
+
+	if(desktopNames) {
+		for(x = 0; x < desktopCount; x++) {
+			Release(desktopNames[x]);
+		}
+		Release(desktopNames);
+		desktopNames = NULL;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void NextDesktop() {
+	ChangeDesktop((currentDesktop + 1) % desktopCount);
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void PreviousDesktop() {
+	if(currentDesktop > 0) {
+		ChangeDesktop(currentDesktop - 1);
+	} else {
+		ChangeDesktop(desktopCount - 1);
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ChangeDesktop(unsigned int desktop) {
+
+	ClientNode *np;
+	unsigned int x;
+
+	if(desktop >= desktopCount) {
+		return;
+	}
+
+	if(currentDesktop == desktop && !initializing) {
+		return;
+	}
+
+	for(x = 0; x < LAYER_COUNT; x++) {
+		for(np = nodes[x]; np; np = np->next) {
+			if(np->state.status & STAT_STICKY) {
+				continue;
+			}
+			if(np->state.desktop == desktop) {
+				ShowClient(np);
+			} else if(np->state.desktop == currentDesktop) {
+				HideClient(np);
+			}
+		}
+	}
+
+	currentDesktop = desktop;
+
+	SetCardinalAtom(rootWindow, ATOM_NET_CURRENT_DESKTOP, currentDesktop);
+	SetCardinalAtom(rootWindow, ATOM_WIN_WORKSPACE, currentDesktop);
+
+	RestackClients();
+
+	UpdatePager();
+	UpdateTaskBar();
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+Menu *CreateDesktopMenu(unsigned int mask) {
+
+	Menu *menu;
+	MenuItem *item;
+	int x;
+
+	menu = Allocate(sizeof(Menu));
+	menu->itemHeight = 0;
+	menu->items = NULL;
+	menu->label = NULL;
+
+	for(x = desktopCount - 1; x >= 0; x--) {
+
+		item = Allocate(sizeof(MenuItem));
+		item->type = MENU_ITEM_NORMAL;
+		item->iconName = NULL;
+		item->submenu = NULL;
+		item->next = menu->items;
+		menu->items = item;
+
+		item->action.type = MA_DESKTOP;
+		item->action.data.i = x;
+
+		item->name = Allocate(strlen(desktopNames[x]) + 3);
+		if(mask & (1 << x)) {
+			strcpy(item->name, "[");
+			strcat(item->name, desktopNames[x]);
+			strcat(item->name, "]");
+		} else {
+			strcpy(item->name, " ");
+			strcat(item->name, desktopNames[x]);
+			strcat(item->name, " ");
+		}
+
+	}
+
+	return menu;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShowDesktop() {
+
+	ClientNode *np;
+	int layer;
+
+	for(layer = 0; layer < LAYER_COUNT; layer++) {
+		for(np = nodes[layer]; np; np = np->next) {
+			if(showingDesktop) {
+				if(np->state.status & STAT_SDESKTOP) {
+					RestoreClient(np, 0);
+				}
+			} else if(np->state.desktop == currentDesktop
+				 || (np->state.status & STAT_STICKY)) {
+				if(np->state.status & (STAT_MAPPED | STAT_SHADED)) {
+					MinimizeClient(np);
+					np->state.status |= STAT_SDESKTOP;
+				}
+			}
+		}
+	}
+
+	showingDesktop = !showingDesktop;
+
+	RestackClients();
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetDesktopCount(const char *str) {
+
+	if(!str) {
+		Warning("invalid desktop count");
+		return;
+	}
+
+	desktopCount = atoi(str);
+	if(desktopCount <= 0 || desktopCount > MAX_DESKTOP_COUNT) {
+		Warning("invalid desktop count: \"%s\"", str);
+		desktopCount = DEFAULT_DESKTOP_COUNT;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetDesktopName(unsigned int desktop, const char *str) {
+
+	unsigned int x;
+
+	if(!str) {
+		Warning("empty Desktops Name tag");
+		return;
+	}
+
+	Assert(desktop >= 0);
+	Assert(desktop < desktopCount);
+
+	if(!desktopNames) {
+		desktopNames = Allocate(desktopCount * sizeof(char*));
+		for(x = 0; x < desktopCount; x++) {
+			desktopNames[x] = NULL;
+		}
+	}
+
+	Assert(desktopNames[desktop] == NULL);
+
+	desktopNames[desktop] = CopyString(str);
+
+}
+
+
diff --git a/src/desktop.h b/src/desktop.h
new file mode 100644
index 0000000..b8e3312
--- /dev/null
+++ b/src/desktop.h
@@ -0,0 +1,60 @@
+/**
+ * @file desktop.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the desktop management functions.
+ *
+ */
+
+#ifndef DESKTOP_H
+#define DESKTOP_H
+
+struct MenuType;
+
+extern char **desktopNames;
+
+/*@{*/
+void InitializeDesktops();
+void StartupDesktops();
+void ShutdownDesktops();
+void DestroyDesktops();
+/*@}*/
+
+/** Switch to the next desktop. */
+void NextDesktop();
+
+/** Switch to the previous desktop. */
+void PreviousDesktop();
+
+/** Switch to a specific desktop.
+ * @param desktop The desktop to show (0 based).
+ */
+void ChangeDesktop(unsigned int desktop);
+
+/** Toggle the "show desktop" state.
+ * This will either minimize or restore all items on the current desktop.
+ */
+void ShowDesktop();
+
+/** Create a menu containing a list of desktops.
+ * @param mask A bit mask of desktops to highlight.
+ * @return A menu containing all the desktops.
+ */
+struct Menu *CreateDesktopMenu(unsigned int mask);
+
+/** Set the number of desktops.
+ * This is called before startup.
+ * @param str ASCII representation of the number of desktops.
+ */
+void SetDesktopCount(const char *str);
+
+/** Set the name of a desktop.
+ * This is called before startup.
+ * @param desktop The desktop to name (0 based).
+ * @param str The name to assign.
+ */
+void SetDesktopName(unsigned int desktop, const char *str);
+
+#endif
+
diff --git a/src/dock.c b/src/dock.c
new file mode 100644
index 0000000..289e85f
--- /dev/null
+++ b/src/dock.c
@@ -0,0 +1,602 @@
+/**
+ * @file dock.c
+ * @author Joe Wingbermuehle
+ * @date 2006
+ *
+ * @brief Dock functions.
+ *
+ */
+
+#include "jwm.h"
+#include "dock.h"
+#include "tray.h"
+#include "main.h"
+#include "error.h"
+#include "color.h"
+
+#define SYSTEM_TRAY_REQUEST_DOCK    0
+#define SYSTEM_TRAY_BEGIN_MESSAGE   1
+#define SYSTEM_TRAY_CANCEL_MESSAGE  2
+
+#define SYSTEM_TRAY_ORIENTATION_HORZ 0
+#define SYSTEM_TRAY_ORIENTATION_VERT 1
+
+/** Structure to represent a docked window. */
+typedef struct DockNode {
+
+	Window window;
+	int needs_reparent;
+
+	struct DockNode *next;
+
+} DockNode;
+
+/** Structure to represent a dock tray component. */
+typedef struct DockType {
+
+	TrayComponentType *cp;
+
+	Window window;
+
+	DockNode *nodes;
+
+} DockType;
+
+static const char *BASE_SELECTION_NAME = "_NET_SYSTEM_TRAY_S%d";
+static const char *ORIENTATION_ATOM = "_NET_SYSTEM_TRAY_ORIENTATION";
+
+static DockType *dock = NULL;
+static int owner = 0;
+static Atom dockAtom;
+static unsigned long orientation;
+
+static void SetSize(TrayComponentType *cp, int width, int height);
+static void Create(TrayComponentType *cp);
+static void Resize(TrayComponentType *cp);
+
+static void DockWindow(Window win);
+static int UndockWindow(Window win);
+
+static void UpdateDock();
+
+/** Initialize dock data. */
+void InitializeDock() {
+}
+
+/** Startup the dock. */
+void StartupDock() {
+
+	char *selectionName;
+
+	if(!dock) {
+		/* No dock has been requested. */
+		return;
+	}
+
+	if(!dock->cp) {
+		/* The Dock item has been removed from the configuration. */
+		JXDestroyWindow(display, dock->window);
+		Release(dock);
+		dock = NULL;
+		return;
+	}
+
+	if(dock->window == None) {
+
+		/* No dock yet. */
+
+		/* Get the selection atom. */
+		selectionName = AllocateStack(strlen(BASE_SELECTION_NAME) + 1);
+		sprintf(selectionName, BASE_SELECTION_NAME, rootScreen);
+		dockAtom = JXInternAtom(display, selectionName, False);
+		ReleaseStack(selectionName);
+
+		/* The location and size of the window doesn't matter here. */
+		dock->window = JXCreateSimpleWindow(display, rootWindow,
+			/* x, y, width, height */ 0, 0, 1, 1,
+			/* border_size, border_color */ 0, 0,
+			/* background */ colors[COLOR_TRAY_BG]);
+		JXSelectInput(display, dock->window,
+			  SubstructureNotifyMask
+			| SubstructureRedirectMask
+			| PointerMotionMask | PointerMotionHintMask);
+
+	}
+	dock->cp->window = dock->window;
+
+}
+
+/** Shutdown the dock. */
+void ShutdownDock() {
+
+	DockNode *np;
+
+	if(dock) {
+
+		if(shouldRestart) {
+
+			/* If restarting we just reparent the dock window to the root
+			 * window. We need to keep the dock around and visible so that
+			 * we don't cause problems with the docked windows.
+			 * It seems every application handles docking differently...
+			 */
+			JXReparentWindow(display, dock->window, rootWindow, 0, 0);
+
+		} else {
+
+			/* JWM is exiting. */
+
+			/* Release memory used by the dock list. */
+			while(dock->nodes) {
+				np = dock->nodes->next;
+				JXReparentWindow(display, dock->nodes->window, rootWindow, 0, 0);
+				Release(dock->nodes);
+				dock->nodes = np;
+			}
+
+			/* Release the selection. */
+			if(owner) {
+				JXSetSelectionOwner(display, dockAtom, None, CurrentTime);
+			}
+
+			/* Destroy the dock window. */
+			JXDestroyWindow(display, dock->window);
+
+		}
+
+	}
+
+}
+
+/** Destroy dock data. */
+void DestroyDock() {
+
+	if(dock) {
+		if(shouldRestart) {
+			dock->cp = NULL;
+		} else {
+			Release(dock);
+			dock = NULL;
+		}
+	}
+
+}
+
+/** Create a dock component. */
+TrayComponentType *CreateDock() {
+
+	TrayComponentType *cp;
+
+	if(dock != NULL && dock->cp != NULL) {
+		Warning("only one Dock allowed");
+		return NULL;
+	} else if(dock == NULL) {
+		dock = Allocate(sizeof(DockType));
+		dock->nodes = NULL;
+		dock->window = None;
+	}
+
+	cp = CreateTrayComponent();
+	cp->object = dock;
+	dock->cp = cp;
+	cp->requestedWidth = 1;
+	cp->requestedHeight = 1;
+
+	cp->SetSize = SetSize;
+	cp->Create = Create;
+	cp->Resize = Resize;
+
+	return cp;
+
+}
+
+/** Set the size of a dock component. */
+void SetSize(TrayComponentType *cp, int width, int height) {
+
+	int count;
+	DockNode *np;
+
+	Assert(cp);
+	Assert(dock);
+
+	count = 0;
+	for(np = dock->nodes; np; np = np->next) {
+		++count;
+	}
+
+	if(width == 0) {
+		if(count > 0) {
+			cp->width = count * height;
+			cp->requestedWidth = cp->width;
+		} else {
+			cp->width = 1;
+			cp->requestedWidth = 1;
+		}
+	} else if(height == 0) {
+		if(count > 0) {
+			cp->height = count * width;
+			cp->requestedHeight = cp->height;
+		} else {
+			cp->height = 1;
+			cp->requestedHeight = 1;
+		}
+	}
+
+}
+
+/** Initialize a dock component. */
+void Create(TrayComponentType *cp) {
+
+	XEvent event;
+	Atom orientationAtom;
+
+	Assert(cp);
+
+	/* Map the dock window. */
+	if(cp->window != None) {
+		JXResizeWindow(display, cp->window, cp->width, cp->height);
+		JXMapRaised(display, cp->window);
+	}
+
+	/* Set the orientation. */
+	orientationAtom = JXInternAtom(display, ORIENTATION_ATOM, False);
+	if(cp->height == 1) {
+		orientation = SYSTEM_TRAY_ORIENTATION_VERT;
+	} else {
+		orientation = SYSTEM_TRAY_ORIENTATION_HORZ;
+	}
+	JXChangeProperty(display, dock->cp->window, orientationAtom,
+		XA_CARDINAL, 32, PropModeReplace, (unsigned char*)&orientation, 1);
+
+	/* Get the selection if we don't already own it.
+	 * If we did already own it, getting it again would cause problems
+	 * with some clients due to the way restarts are handled.
+	 */
+	if(!owner) {
+
+		owner = 1;
+		JXSetSelectionOwner(display, dockAtom, dock->cp->window, CurrentTime);
+		if(JXGetSelectionOwner(display, dockAtom) != dock->cp->window) {
+
+			owner = 0;
+			Warning("could not acquire system tray selection");
+
+		} else {
+
+			memset(&event, 0, sizeof(event));
+			event.xclient.type = ClientMessage;
+			event.xclient.window = rootWindow;
+			event.xclient.message_type = JXInternAtom(display, "MANAGER", False);
+			event.xclient.format = 32;
+			event.xclient.data.l[0] = CurrentTime;
+			event.xclient.data.l[1] = dockAtom;
+			event.xclient.data.l[2] = dock->cp->window;
+			event.xclient.data.l[3] = 0;
+			event.xclient.data.l[4] = 0;
+
+			JXSendEvent(display, rootWindow, False, StructureNotifyMask, &event);
+
+		}
+
+	}
+
+}
+
+/** Resize a dock component. */
+void Resize(TrayComponentType *cp) {
+
+	Assert(cp);
+
+	JXResizeWindow(display, cp->window, cp->width, cp->height);
+	UpdateDock();
+
+}
+
+/** Handle a dock event. */
+void HandleDockEvent(const XClientMessageEvent *event) {
+
+	Assert(event);
+
+	switch(event->data.l[1]) {
+	case SYSTEM_TRAY_REQUEST_DOCK:
+		DockWindow(event->data.l[2]);
+		break;
+	case SYSTEM_TRAY_BEGIN_MESSAGE:
+		break;
+	case SYSTEM_TRAY_CANCEL_MESSAGE:
+		break;
+	default:
+		Debug("invalid opcode in dock event");
+		break;
+	}
+
+}
+
+/** Handle a resize request event. */
+int HandleDockResizeRequest(const XResizeRequestEvent *event) {
+
+	DockNode *np;
+
+	Assert(event);
+
+	if(!dock) {
+		return 0;
+	}
+
+	for(np = dock->nodes; np; np = np->next) {
+		if(np->window == event->window) {
+
+			JXResizeWindow(display, np->window, event->width, event->height);
+			UpdateDock();
+
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+/** Handle a configure request event. */
+int HandleDockConfigureRequest(const XConfigureRequestEvent *event) {
+
+	XWindowChanges wc;
+	DockNode *np;
+
+	Assert(event);
+
+	if(!dock) {
+		return 0;
+	}
+
+	for(np = dock->nodes; np; np = np->next) {
+		if(np->window == event->window) {
+			wc.stack_mode = event->detail;
+			wc.sibling = event->above;
+			wc.border_width = event->border_width;
+			wc.x = event->x;
+			wc.y = event->y;
+			wc.width = event->width;
+			wc.height = event->height;
+			JXConfigureWindow(display, np->window, event->value_mask, &wc);
+			UpdateDock();
+			return 1;
+		}
+	}
+
+	return 0;
+
+}
+
+/** Handle a reparent notify event. */
+int HandleDockReparentNotify(const XReparentEvent *event) {
+
+	DockNode *np;
+	int handled;
+
+	Assert(event);
+
+	/* Just return if there is no dock. */
+	if(!dock) {
+		return 0;
+	}
+
+	/* Check each docked window. */
+	handled = 0;
+	for(np = dock->nodes; np; np = np->next) {
+		if(np->window == event->window) {
+			if(event->parent != dock->cp->window) {
+				/* For some reason the application reparented the window.
+				 * We make note of this condition and reparent every time
+				 * the dock is updated. Unfortunately we can't do this for
+				 * all applications because some won't deal with it.
+				 */
+				np->needs_reparent = 1;
+				handled = 1;
+			}
+		}
+	}
+
+	/* Layout the stuff on the dock again if something happened. */
+	if(handled) {
+		UpdateDock();
+	}
+
+	return handled;
+
+}
+
+/** Handle a destroy event. */
+int HandleDockDestroy(Window win) {
+
+	if(dock) {
+		return UndockWindow(win);
+	} else {
+		return 0;
+	}
+
+}
+
+/** Handle a selection clear event. */
+int HandleDockSelectionClear(const XSelectionClearEvent *event) {
+
+	if(event->selection == dockAtom) {
+		Debug("lost _NET_SYSTEM_TRAY selection");
+		owner = 0;
+	}
+
+	return 0;
+
+}
+
+/** Add a window to the dock. */
+void DockWindow(Window win) {
+
+	DockNode *np;
+
+	Assert(dock);
+
+	/* Make sure we have a valid window to add. */
+	if(win == None) {
+		return;
+	}
+
+	/* If this window is already docked ignore it. */
+	for(np = dock->nodes; np; np = np->next) {
+		if(np->window == win) {
+			return;
+		}
+	}
+
+	/* Add the window to our list. */
+	np = Allocate(sizeof(DockNode));
+	np->window = win;
+	np->needs_reparent = 0;
+	np->next = dock->nodes;
+	dock->nodes = np;
+
+	/* Update the requested size. */
+	if(orientation == SYSTEM_TRAY_ORIENTATION_HORZ) {
+		if(dock->cp->requestedWidth > 1) {
+			dock->cp->requestedWidth += dock->cp->height;
+		} else {
+			dock->cp->requestedWidth = dock->cp->height;
+		}
+	} else {
+		if(dock->cp->requestedHeight > 1) {
+			dock->cp->requestedHeight += dock->cp->width;
+		} else {
+			dock->cp->requestedHeight = dock->cp->width;
+		}
+	}
+
+	/* It's safe to reparent at (0, 0) since we call
+	 * ResizeTray which will invoke the Resize callback.
+	 */
+	JXAddToSaveSet(display, win);
+	JXSelectInput(display, win,
+		  StructureNotifyMask
+		| ResizeRedirectMask
+		| PointerMotionMask | PointerMotionHintMask);
+	JXReparentWindow(display, win, dock->cp->window, 0, 0);
+	JXMapRaised(display, win);
+
+	/* Resize the tray containing the dock. */
+	ResizeTray(dock->cp->tray);
+
+}
+
+/** Remove a window from the dock. */
+int UndockWindow(Window win) {
+
+	DockNode *np;
+	DockNode *last;
+
+	Assert(dock);
+
+	last = NULL;
+	for(np = dock->nodes; np; np = np->next) {
+		if(np->window == win) {
+
+			/* Remove the window from our list. */
+			if(last) {
+				last->next = np->next;
+			} else {
+				dock->nodes = np->next;
+			}
+			Release(np);
+
+			/* Update the requested size. */
+			if(orientation == SYSTEM_TRAY_ORIENTATION_HORZ) {
+				dock->cp->requestedWidth -= dock->cp->height;
+				if(dock->cp->requestedWidth <= 0) {
+					dock->cp->requestedWidth = 1;
+				}
+			} else {
+				dock->cp->requestedHeight -= dock->cp->width;
+				if(dock->cp->requestedHeight <= 0) {
+					dock->cp->requestedHeight = 1;
+				}
+			}
+
+			/* Resize the tray. */
+			ResizeTray(dock->cp->tray);
+
+			return 1;
+
+		}
+		last = np;
+	}
+
+	return 0;
+}
+
+/** Layout items on the dock. */
+void UpdateDock() {
+
+	XWindowAttributes attr;
+	DockNode *np;
+	int x, y;
+	int width, height;
+	int xoffset, yoffset;
+	int itemWidth, itemHeight;
+	double ratio;
+
+	Assert(dock);
+
+	/* Determine the size of items in the dock. */
+	if(orientation == SYSTEM_TRAY_ORIENTATION_HORZ) {
+		itemWidth = dock->cp->height;
+		itemHeight = dock->cp->height;
+	} else {
+		itemHeight = dock->cp->width;
+		itemWidth = dock->cp->width;
+	}
+
+	x = 0;
+	y = 0;
+	for(np = dock->nodes; np; np = np->next) {
+
+		xoffset = 0;
+		yoffset = 0;
+		width = itemWidth;
+		height = itemHeight;
+
+		if(JXGetWindowAttributes(display, np->window, &attr)) {
+
+			ratio = (double)attr.width / attr.height;
+
+			if(ratio > 1.0) {
+				if(width > attr.width) {
+					width = attr.width;
+				}
+				height = width / ratio;
+			} else {
+				if(height > attr.height) {
+					height = attr.height;
+				}
+				width = height * ratio;
+			}
+
+			xoffset = (itemWidth - width) / 2;
+			yoffset = (itemHeight - height) / 2;
+
+		}
+
+		JXMoveResizeWindow(display, np->window, x + xoffset, y + yoffset,
+			width, height);
+
+		/* Reparent if this window likes to go other places. */
+		if(np->needs_reparent) {
+			JXReparentWindow(display, np->window, dock->cp->window,
+			x + xoffset, y + yoffset);
+		}
+
+		if(orientation == SYSTEM_TRAY_ORIENTATION_HORZ) {
+			x += itemWidth;
+		} else {
+			y += itemHeight;
+		}
+	}
+
+}
+
diff --git a/src/dock.h b/src/dock.h
new file mode 100644
index 0000000..307f348
--- /dev/null
+++ b/src/dock.h
@@ -0,0 +1,43 @@
+/**
+ * @file dock.h
+ * @author Joe Wingbermuehle
+ * @date 2006
+ *
+ * @brief Header for the dock functions.
+ *
+ */
+
+#ifndef DOCK_H
+#define DOCK_H
+
+struct TrayComponentType;
+
+/*@{*/
+void InitializeDock();
+void StartupDock();
+void ShutdownDock();
+void DestroyDock();
+/*@}*/
+
+/** Create a dock to be used for notifications.
+ * Note that only one dock can be created.
+ */
+struct TrayComponentType *CreateDock();
+
+/** Handle a client message sent to the dock window.
+ * @param event The event.
+ */
+void HandleDockEvent(const XClientMessageEvent *event);
+
+int HandleDockDestroy(Window win);
+
+int HandleDockSelectionClear(const XSelectionClearEvent *event);
+
+int HandleDockResizeRequest(const XResizeRequestEvent *event);
+
+int HandleDockConfigureRequest(const XConfigureRequestEvent *event);
+
+int HandleDockReparentNotify(const XReparentEvent *event);
+
+#endif
+
diff --git a/src/error.c b/src/error.c
new file mode 100644
index 0000000..a4b1277
--- /dev/null
+++ b/src/error.c
@@ -0,0 +1,108 @@
+/**
+ * @file error.c
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Error handling functions.
+ *
+ */
+
+#include "jwm.h"
+#include "error.h"
+#include "main.h"
+
+/** Log a fatal error and exit. */
+void FatalError(const char *str, ...) {
+
+	va_list ap;
+	va_start(ap, str);
+
+	Assert(str);
+
+	fprintf(stderr, "JWM: error: ");
+	vfprintf(stderr, str, ap);
+	fprintf(stderr, "\n");
+
+	va_end(ap);
+
+	exit(1);
+
+}
+
+/** Log a warning. */
+void Warning(const char *str, ...) {
+
+	va_list ap;
+	va_start(ap, str);
+
+	Assert(str);
+
+	WarningVA(NULL, str, ap);
+
+	va_end(ap);
+
+}
+
+/** Log a warning. */
+void WarningVA(const char *part, const char *str, va_list ap) {
+
+	Assert(str);
+
+	fprintf(stderr, "JWM: warning: ");
+	if(part) {
+		fprintf(stderr, "%s: ", part);
+	}
+	vfprintf(stderr, str, ap);
+	fprintf(stderr, "\n");
+
+}
+
+/** Callback to handle errors from Xlib.
+ * Note that if debug output is directed to an X terminal, emitting too
+ * much output can cause a dead lock (this happens on HP-UX). Therefore
+ * ShowCheckpoint isn't used by default.
+ */
+int ErrorHandler(Display *d, XErrorEvent *e) {
+
+#ifdef DEBUG
+
+	char buffer[64];
+	char code[32];
+
+#endif
+
+	if(initializing) {
+		if(e->request_code == X_ChangeWindowAttributes
+			&& e->error_code == BadAccess) {
+			FatalError("display is already managed");
+		}
+	}
+
+#ifdef DEBUG
+
+	if(!e) {
+		fprintf(stderr, "XError: [no information]\n");
+		return 0;
+	}
+
+	XGetErrorText(display, e->error_code, buffer, sizeof(buffer));
+	Debug("XError: %s", buffer);
+
+	snprintf(code, sizeof(code), "%d", e->request_code);
+	XGetErrorDatabaseText(display, "XRequest", code, "?",
+		buffer, sizeof(buffer));
+	Debug("   Request Code: %d (%s)", e->request_code, buffer);
+	Debug("   Minor Code: %d", e->minor_code);
+	Debug("   Resource ID: 0x%lx", (unsigned long)e->resourceid);
+	Debug("   Error Serial: %lu", (unsigned long)e->serial);
+
+#if 0
+	ShowCheckpoint();
+#endif
+
+#endif
+
+	return 0;
+
+}
+
diff --git a/src/error.h b/src/error.h
new file mode 100644
index 0000000..5028db4
--- /dev/null
+++ b/src/error.h
@@ -0,0 +1,38 @@
+/**
+ * @file error.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the error functions.
+ *
+ */
+
+#ifndef ERROR_H
+#define ERROR_H
+
+/** Display and error message and terminate the program.
+ * @param str The format of the message to display.
+ */
+void FatalError(const char *str, ...);
+
+/** Display a warning message.
+ * @param str The format of the message to display.
+ */
+void Warning(const char *str, ...);
+
+/** Display a warning message.
+ * @param part A section identifier for the message.
+ * @param str The format string of the message to display.
+ * @param ap The argument list.
+ */
+void WarningVA(const char *part, const char *str, va_list ap);
+
+/** Handle an XError event.
+ * @param d The display on which the event occurred.
+ * @param e The error event.
+ * @return 0
+ */
+int ErrorHandler(Display *d, XErrorEvent *e);
+
+#endif
+
diff --git a/src/event.c b/src/event.c
new file mode 100644
index 0000000..3c4f0bb
--- /dev/null
+++ b/src/event.c
@@ -0,0 +1,1138 @@
+/****************************************************************************
+ * Functions to handle XServer events.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "event.h"
+#include "client.h"
+#include "main.h"
+#include "hint.h"
+#include "tray.h"
+#include "pager.h"
+#include "desktop.h"
+#include "cursor.h"
+#include "icon.h"
+#include "taskbar.h"
+#include "confirm.h"
+#include "swallow.h"
+#include "popup.h"
+#include "winmenu.h"
+#include "root.h"
+#include "move.h"
+#include "resize.h"
+#include "key.h"
+#include "clock.h"
+#include "place.h"
+#include "dock.h"
+#include "timing.h"
+#include "traybutton.h"
+
+#define MIN_TIME_DELTA 50
+
+static void Signal();
+static void DispatchBorderButtonEvent(const XButtonEvent *event,
+	ClientNode *np);
+
+static void HandleConfigureRequest(const XConfigureRequestEvent *event);
+static int HandleExpose(const XExposeEvent *event);
+static int HandlePropertyNotify(const XPropertyEvent *event);
+static void HandleClientMessage(const XClientMessageEvent *event);
+static void HandleColormapChange(const XColormapEvent *event);
+static int HandleDestroyNotify(const XDestroyWindowEvent *event);
+static void HandleMapRequest(const XMapEvent *event);
+static void HandleUnmapNotify(const XUnmapEvent *event);
+static void HandleButtonEvent(const XButtonEvent *event);
+static void HandleKeyPress(const XKeyEvent *event);
+static void HandleEnterNotify(const XCrossingEvent *event);
+static void HandleLeaveNotify(const XCrossingEvent *event);
+static void HandleMotionNotify(const XMotionEvent *event);
+static int HandleSelectionClear(const XSelectionClearEvent *event);
+
+static void HandleNetMoveResize(const XClientMessageEvent *event,
+	ClientNode *np);
+static void HandleNetWMState(const XClientMessageEvent *event,
+	ClientNode *np);
+
+#ifdef USE_SHAPE
+static void HandleShapeEvent(const XShapeEvent *event);
+#endif
+
+/****************************************************************************
+ ****************************************************************************/
+void WaitForEvent(XEvent *event) {
+
+	struct timeval timeout;
+	fd_set fds;
+	int fd;
+	int handled;
+
+	fd = JXConnectionNumber(display);
+
+	do {
+
+		while(JXPending(display) == 0) {
+			FD_ZERO(&fds);
+			FD_SET(fd, &fds);
+			timeout.tv_usec = 0;
+			timeout.tv_sec = 1;
+			if(select(fd + 1, &fds, NULL, NULL, &timeout) <= 0) {
+				Signal();
+			}
+		}
+
+		Signal();
+
+		JXNextEvent(display, event);
+
+		switch(event->type) {
+		case ConfigureRequest:
+			HandleConfigureRequest(&event->xconfigurerequest);
+			handled = 1;
+			break;
+		case MapRequest:
+			HandleMapRequest(&event->xmap);
+			handled = 1;
+			break;
+		case PropertyNotify:
+			handled = HandlePropertyNotify(&event->xproperty);
+			break;
+		case ClientMessage:
+			HandleClientMessage(&event->xclient);
+			handled = 1;
+			break;
+		case UnmapNotify:
+			HandleUnmapNotify(&event->xunmap);
+			handled = 1;
+			break;
+		case Expose:
+			handled = HandleExpose(&event->xexpose);
+			break;
+		case ColormapNotify:
+			HandleColormapChange(&event->xcolormap);
+			handled = 1;
+			break;
+		case DestroyNotify:
+			handled = HandleDestroyNotify(&event->xdestroywindow);
+			break;
+		case SelectionClear:
+			handled = HandleSelectionClear(&event->xselectionclear);
+			break;
+		case ResizeRequest:
+			handled = HandleDockResizeRequest(&event->xresizerequest);
+			break;
+		case MotionNotify:
+			SetMousePosition(event->xmotion.x_root, event->xmotion.y_root);
+			handled = 0;
+			break;
+		case ReparentNotify:
+			HandleDockReparentNotify(&event->xreparent);
+			handled = 1;
+			break;
+		case ConfigureNotify:
+			handled = 0;
+			break;
+		case CreateNotify:
+		case MapNotify:
+		case GraphicsExpose:
+		case NoExpose:
+			handled = 1;
+			break;
+		default:
+#ifdef USE_SHAPE
+			if(haveShape && event->type == shapeEvent) {
+				HandleShapeEvent((XShapeEvent*)event);
+				handled = 1;
+			} else {
+				handled = 0;
+			}
+#else
+			handled = 0;
+#endif
+			break;
+		}
+
+		if(!handled) {
+			handled = ProcessTrayEvent(event);
+		}
+		if(!handled) {
+			handled = ProcessDialogEvent(event);
+		}
+		if(!handled) {
+			handled = ProcessSwallowEvent(event);
+		}
+		if(!handled) {
+			handled = ProcessPopupEvent(event);
+		}
+
+	} while(handled && !shouldExit);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void Signal() {
+
+	static TimeType last = ZERO_TIME;
+
+	TimeType now;
+	int x, y;
+
+	GetCurrentTime(&now);
+
+	if(GetTimeDifference(&now, &last) < MIN_TIME_DELTA) {
+		return;
+	}
+	last = now;
+
+	GetMousePosition(&x, &y);
+
+	SignalTaskbar(&now, x, y);
+	SignalTrayButton(&now, x, y);
+	SignalClock(&now, x, y);
+	SignalTray(&now, x, y);
+	SignalPopup(&now, x, y);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ProcessEvent(XEvent *event) {
+
+	switch(event->type) {
+	case ButtonPress:
+	case ButtonRelease:
+		HandleButtonEvent(&event->xbutton);
+		break;
+	case KeyPress:
+		HandleKeyPress(&event->xkey);
+		break;
+	case EnterNotify:
+		HandleEnterNotify(&event->xcrossing);
+		break;
+	case LeaveNotify:
+		HandleLeaveNotify(&event->xcrossing);
+		break;
+	case MotionNotify:
+		while(JXCheckTypedEvent(display, MotionNotify, event));
+		HandleMotionNotify(&event->xmotion);
+		break;
+	case DestroyNotify:
+	case Expose:
+	case KeyRelease:
+	case ConfigureNotify:
+		break;
+	default:
+		Debug("Unknown event type: %d", event->type);
+		break;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DiscardMotionEvents(XEvent *event, Window w) {
+
+	XEvent temp;
+
+	while(JXCheckTypedEvent(display, MotionNotify, &temp)) {
+		SetMousePosition(temp.xmotion.x_root, temp.xmotion.y_root);
+		if(temp.xmotion.window == w) {
+			*event = temp;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int HandleSelectionClear(const XSelectionClearEvent *event) {
+
+	return HandleDockSelectionClear(event);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleButtonEvent(const XButtonEvent *event) {
+
+	int x, y;
+	ClientNode *np;
+	int north, south, east, west;
+	int allowMode;
+
+	np = FindClientByParent(event->window);
+	if(np) {
+		RaiseClient(np);
+		if(focusModel == FOCUS_CLICK) {
+			FocusClient(np);
+		}
+		switch(event->button) {
+		case Button1:
+			DispatchBorderButtonEvent(event, np);
+			break;
+		case Button2:
+			MoveClient(np, event->x, event->y);
+			break;
+		case Button3:
+			GetBorderSize(np, &north, &south, &east, &west);
+			x = event->x + np->x - west;
+			y = event->y + np->y - north;
+			ShowWindowMenu(np, x, y);
+			break;
+		case Button4:
+			ShadeClient(np);
+			break;
+		case Button5:
+			UnshadeClient(np);
+			break;
+		default:
+			break;
+		}
+	} else if(event->window == rootWindow && event->type == ButtonPress) {
+		if(!ShowRootMenu(event->button, event->x, event->y)) {
+			if(event->button == 4) {
+				PreviousDesktop();
+			} else if(event->button == 5) {
+				NextDesktop();
+			}
+		}
+	} else {
+		np = FindClientByWindow(event->window);
+		if(np) {
+			allowMode = ReplayPointer;
+			switch(event->button) {
+			case Button1:
+			case Button2:
+				RaiseClient(np);
+				if(focusModel == FOCUS_CLICK) {
+					FocusClient(np);
+				}
+				if(event->state & Mod1Mask) {
+					GetBorderSize(np, &north, &south, &east, &west);
+					MoveClient(np, event->x + west, event->y + north);
+				}
+				break;
+			case Button3:
+				if(event->state & Mod1Mask) {
+					LowerClient(np);
+					allowMode = SyncPointer;
+				} else {
+					RaiseClient(np);
+					if(focusModel == FOCUS_CLICK) {
+						FocusClient(np);
+					}
+				}
+				break;
+			default:
+				break;
+			}
+			JXAllowEvents(display, allowMode, CurrentTime);
+		}
+	}
+
+	UpdatePager();
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleKeyPress(const XKeyEvent *event) {
+	ClientNode *np;
+	KeyType key;
+
+	key = GetKey(event);
+
+	np = GetActiveClient();
+
+	switch(key & 0xFF) {
+	case KEY_EXEC:
+		RunKeyCommand(event);
+		break;
+	case KEY_DESKTOP:
+		if(key >> 8) {
+			ChangeDesktop((key >> 8) - 1);
+		} else {
+			NextDesktop();
+		}
+		break;
+	case KEY_NEXT:
+		FocusNext();
+		break;
+	case KEY_NEXT_STACKED:
+		FocusNextStackedCircular();
+		break;
+	case KEY_CLOSE:
+		if(np) {
+			DeleteClient(np);
+		}
+		break;
+	case KEY_SHADE:
+		if(np) {
+			if(np->state.status & STAT_SHADED) {
+				UnshadeClient(np);
+			} else {
+				ShadeClient(np);
+			}
+		}
+		break;
+	case KEY_MOVE:
+		if(np) {
+			MoveClientKeyboard(np);
+		}
+		break;
+	case KEY_RESIZE:
+		if(np) {
+			ResizeClientKeyboard(np);
+		}
+		break;
+	case KEY_MIN:
+		if(np) {
+			MinimizeClient(np);
+		}
+		break;
+	case KEY_MAX:
+		if(np) {
+			MaximizeClient(np);
+		}
+		break;
+	case KEY_ROOT:
+		ShowKeyMenu(event);
+		break;
+	case KEY_WIN:
+		if(np) {
+			ShowWindowMenu(np, np->x, np->y);
+		}
+		break;
+	case KEY_RESTART:
+		Restart();
+		break;
+	case KEY_EXIT:
+		Exit();
+		break;
+	default:
+		break;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleConfigureRequest(const XConfigureRequestEvent *event) {
+
+	XWindowChanges wc;
+	ClientNode *np;
+	int north, south, east, west;
+	int changed;
+	int handled;
+
+	handled = HandleDockConfigureRequest(event);
+	if(handled) {
+		return;
+	}
+
+	np = FindClientByWindow(event->window);
+	if(np && np->window == event->window) {
+
+		changed = 0;
+		if((event->value_mask & CWWidth) && (event->width != np->width)) {
+			np->width = event->width;
+			changed = 1;
+		}
+		if((event->value_mask & CWHeight) && (event->height != np->height)) {
+			np->height = event->height;
+			changed = 1;
+		}
+		if((event->value_mask & CWX) && (event->x != np->x)) {
+			np->x = event->x;
+			changed = 1;
+		}
+		if((event->value_mask & CWY) && (event->y != np->y)) {
+			np->y = event->y;
+			changed = 1;
+		}
+
+		if(!changed) {
+			return;
+		}
+
+		if(np->controller) {
+			(np->controller)(0);
+		}
+
+		GetBorderSize(np, &north, &south, &east, &west);
+
+		wc.stack_mode = Above;
+		wc.sibling = np->parent;
+		wc.border_width = 0;
+
+		ConstrainSize(np);
+
+		if(np->state.status & STAT_MAXIMIZED) {
+			np->state.status &= ~STAT_MAXIMIZED;
+		}
+
+		wc.x = np->x;
+		wc.y = np->y;
+		wc.width = np->width + east + west;
+		wc.height = np->height + north + south;
+		JXConfigureWindow(display, np->parent, event->value_mask, &wc);
+
+		wc.x = west;
+		wc.y = north;
+		wc.width = np->width;
+		wc.height = np->height;
+		JXConfigureWindow(display, np->window, event->value_mask, &wc);
+
+	} else {
+
+		wc.stack_mode = event->detail;
+		wc.sibling = event->above;
+		wc.border_width = event->border_width;
+		wc.x = event->x;
+		wc.y = event->y;
+		wc.width = event->width > rootWidth ? rootWidth : event->width;
+		wc.height = event->height > rootHeight ? rootHeight : event->height;
+		JXConfigureWindow(display, event->window, event->value_mask, &wc);
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleEnterNotify(const XCrossingEvent *event) {
+
+	ClientNode *np;
+	Cursor cur;
+
+	SetMousePosition(event->x_root, event->y_root);
+
+	np = FindClientByWindow(event->window);
+	if(np) {
+		if(!(np->state.status & STAT_ACTIVE) && (focusModel == FOCUS_SLOPPY)) {
+			FocusClient(np);
+		}
+		if(np->parent == event->window) {
+			np->borderAction = GetBorderActionType(np, event->x, event->y);
+			cur = GetFrameCursor(np->borderAction);
+			JXDefineCursor(display, np->parent, cur);
+		} else if(np->borderAction != BA_NONE) {
+			SetDefaultCursor(np->parent);
+			np->borderAction = BA_NONE;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleLeaveNotify(const XCrossingEvent *event) {
+
+	ClientNode *np;
+
+	SetMousePosition(event->x_root, event->y_root);
+
+	np = FindClientByParent(event->window);
+	if(np) {
+		SetDefaultCursor(np->parent);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int HandleExpose(const XExposeEvent *event) {
+
+	ClientNode *np;
+
+	np = FindClientByWindow(event->window);
+	if(np) {
+		if(event->window == np->parent) {
+			DrawBorder(np, event);
+			return 1;
+		} else if(event->window == np->window
+			&& np->state.status & STAT_WMDIALOG) {
+			return 0;
+		} else {
+			return 1;
+		}
+	} else {
+		return event->count ? 1 : 0;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int HandlePropertyNotify(const XPropertyEvent *event) {
+
+	ClientNode *np;
+	int changed;
+
+	np = FindClientByWindow(event->window);
+	if(np) {
+		changed = 0;
+		switch(event->atom) {
+		case XA_WM_NAME:
+			ReadWMName(np);
+			changed = 1;
+			break;
+		case XA_WM_NORMAL_HINTS:
+			ReadWMNormalHints(np);
+			changed = 1;
+			break;
+		case XA_WM_HINTS:
+		case XA_WM_ICON_NAME:
+		case XA_WM_CLIENT_MACHINE:
+			break;
+		default:
+			if(event->atom == atoms[ATOM_WM_COLORMAP_WINDOWS]) {
+				ReadWMColormaps(np);
+				UpdateClientColormap(np);
+			} else if(event->atom == atoms[ATOM_NET_WM_ICON]) {
+				LoadIcon(np);
+				changed = 1;
+			} else if(event->atom == atoms[ATOM_NET_WM_NAME]) {
+				ReadWMName(np);
+				changed = 1;
+			} else if(event->atom == atoms[ATOM_NET_WM_STRUT_PARTIAL]) {
+				ReadClientStrut(np);
+			} else if(event->atom == atoms[ATOM_NET_WM_STRUT]) {
+				ReadClientStrut(np);
+			}
+			break;
+		}
+
+		if(changed) {
+			DrawBorder(np, NULL);
+			UpdateTaskBar();
+			UpdatePager();
+		}
+		if(np->state.status & STAT_WMDIALOG) {
+			return 0;
+		} else {
+			return 1;
+		}
+	}
+
+	return 1;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleClientMessage(const XClientMessageEvent *event) {
+
+	ClientNode *np;
+	long mask, flags;
+#ifdef DEBUG
+	char *atomName;
+#endif
+
+	np = FindClientByWindow(event->window);
+	if(np) {
+		if(event->message_type == atoms[ATOM_WIN_STATE]) {
+
+			mask = event->data.l[0];
+			flags = event->data.l[1];
+
+			if(mask & WIN_STATE_STICKY) {
+				if(flags & WIN_STATE_STICKY) {
+					SetClientSticky(np, 1);
+				} else {
+					SetClientSticky(np, 0);
+				}
+			}
+
+			if(mask & WIN_STATE_HIDDEN) {
+				if(flags & WIN_STATE_HIDDEN) {
+					np->state.status |= STAT_NOLIST;
+				} else {
+					np->state.status &= ~STAT_NOLIST;
+				}
+				UpdateTaskBar();
+				UpdatePager();
+			}
+
+		} else if(event->message_type == atoms[ATOM_WIN_LAYER]) {
+
+			SetClientLayer(np, event->data.l[0]);
+
+		} else if(event->message_type == atoms[ATOM_WM_CHANGE_STATE]) {
+
+			if(np->controller) {
+				(np->controller)(0);
+			}
+
+			switch(event->data.l[0]) {
+			case WithdrawnState:
+				SetClientWithdrawn(np);
+				break;
+			case IconicState:
+				MinimizeClient(np);
+				break;
+			case NormalState:
+				RestoreClient(np, 1);
+				break;
+			default:
+				break;
+			}
+
+		} else if(event->message_type == atoms[ATOM_NET_ACTIVE_WINDOW]) {
+
+			RestoreClient(np, 1);
+			FocusClient(np);
+
+		} else if(event->message_type == atoms[ATOM_NET_WM_DESKTOP]) {
+
+			if(event->data.l[0] == ~0L) {
+				SetClientSticky(np, 1);
+			} else {
+
+				if(np->controller) {
+					(np->controller)(0);
+				}
+
+				if(event->data.l[0] >= 0 && event->data.l[0] < (long)desktopCount) {
+					np->state.status &= ~STAT_STICKY;
+					SetClientDesktop(np, event->data.l[0]);
+				}
+			}
+
+		} else if(event->message_type == atoms[ATOM_NET_CLOSE_WINDOW]) {
+
+			DeleteClient(np);
+
+		} else if(event->message_type == atoms[ATOM_NET_MOVERESIZE_WINDOW]) {
+
+			HandleNetMoveResize(event, np);
+
+		} else if(event->message_type == atoms[ATOM_NET_WM_STATE]) {
+
+			HandleNetWMState(event, np);
+
+		} else {
+
+#ifdef DEBUG
+			atomName = JXGetAtomName(display, event->message_type);
+			Debug("Uknown ClientMessage to client: %s", atomName);
+			JXFree(atomName);
+#endif
+
+		}
+
+	} else if(event->window == rootWindow) {
+
+		if(event->message_type == atoms[ATOM_JWM_RESTART]) {
+			Restart();
+		} else if(event->message_type == atoms[ATOM_JWM_EXIT]) {
+			Exit();
+		} else if(event->message_type == atoms[ATOM_NET_CURRENT_DESKTOP]) {
+			ChangeDesktop(event->data.l[0]);
+		} else {
+#ifdef DEBUG
+			atomName = JXGetAtomName(display, event->message_type);
+			Debug("Uknown ClientMessage to root: %s", atomName);
+			JXFree(atomName);
+#endif
+		}
+
+	} else if(event->message_type == atoms[ATOM_NET_SYSTEM_TRAY_OPCODE]) {
+
+		HandleDockEvent(event);
+
+	}
+
+}
+
+/****************************************************************************
+ * Handle a _NET_MOVERESIZE_WINDOW request.
+ ****************************************************************************/
+void HandleNetMoveResize(const XClientMessageEvent *event, ClientNode *np) {
+
+	long flags, gravity;
+	long x, y;
+	long width, height;
+	int deltax, deltay;
+	int north, south, east, west;
+
+	Assert(event);
+	Assert(np);
+
+	gravity = event->data.l[0] & 0xFF;
+	flags = event->data.l[0] >> 8;
+
+	x = np->x;
+	y = np->y;
+	width = np->width;
+	height = np->height;
+
+	if(flags & (1 << 0)) {
+		x = event->data.l[1];
+	}
+	if(flags & (1 << 1)) {
+		y = event->data.l[2];
+	}
+	if(flags & (1 << 2)) {
+		width = event->data.l[3];
+	}
+	if(flags & (1 << 3)) {
+		height = event->data.l[4];
+	}
+
+	if(gravity == 0) {
+		gravity = np->gravity;
+	}
+
+	GetBorderSize(np, &north, &south, &east, &west);
+	GetGravityDelta(np, &deltax, &deltay);
+
+	x -= deltax;
+	y -= deltay;
+
+	np->x = x;
+	np->y = y;
+	np->width = width;
+	np->height = height;
+
+	JXMoveResizeWindow(display, np->parent,
+		np->x - west, np->y - north,
+		np->width + east + west,
+		np->height + north + south);
+	JXMoveResizeWindow(display, np->window, west, north,
+		np->width, np->height);
+
+	WriteState(np);
+	SendConfigureEvent(np);
+
+}
+
+/****************************************************************************
+ * Handle a _NET_WM_STATE request.
+ ****************************************************************************/
+void HandleNetWMState(const XClientMessageEvent *event, ClientNode *np) {
+
+	int actionMaximize;
+	int actionStick;
+	int actionShade;
+	int actionFullScreen;
+	int x;
+
+	/* Up to two actions to be applied together, figure it out. */
+	actionMaximize = 0;
+	actionStick = 0;
+	actionShade = 0;
+	actionFullScreen = 0;
+
+	for(x = 1; x <= 2; x++) {
+		if(event->data.l[x]
+			== (long)atoms[ATOM_NET_WM_STATE_STICKY]) {
+			actionStick = 1;
+		} else if(event->data.l[x]
+			== (long)atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT]) {
+			actionMaximize = 1;
+		} else if(event->data.l[x]
+			== (long)atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ]) {
+			actionMaximize = 1;
+		} else if(event->data.l[x]
+			== (long)atoms[ATOM_NET_WM_STATE_SHADED]) {
+			actionShade = 1;
+		} else if(event->data.l[x]
+			== (long)atoms[ATOM_NET_WM_STATE_FULLSCREEN]) {
+			actionFullScreen = 1;
+		}
+	}
+
+	switch(event->data.l[0]) {
+	case 0: /* Remove */
+		if(actionStick) {
+			SetClientSticky(np, 0);
+		}
+		if(actionMaximize && (np->state.status & STAT_MAXIMIZED)) {
+			MaximizeClient(np);
+		}
+		if(actionShade) {
+			UnshadeClient(np);
+		}
+		if(actionFullScreen) {
+			SetClientFullScreen(np, 0);
+		}
+		break;
+	case 1: /* Add */
+		if(actionStick) {
+			SetClientSticky(np, 1);
+		}
+		if(actionMaximize && !(np->state.status & STAT_MAXIMIZED)) {
+			MaximizeClient(np);
+		}
+		if(actionShade) {
+			ShadeClient(np);
+		}
+		if(actionFullScreen) {
+			SetClientFullScreen(np, 1);
+		}
+		break;
+	case 2: /* Toggle */
+		if(actionStick) {
+			if(np->state.status & STAT_STICKY) {
+				SetClientSticky(np, 0);
+			} else {
+				SetClientSticky(np, 1);
+			}
+		}
+		if(actionMaximize) {
+			MaximizeClient(np);
+		}
+		if(actionShade) {
+			if(np->state.status & STAT_SHADED) {
+				UnshadeClient(np);
+			} else {
+				ShadeClient(np);
+			}
+		}
+		if(actionFullScreen) {
+			if(np->state.status & STAT_FULLSCREEN) {
+				SetClientFullScreen(np, 0);
+			} else {
+				SetClientFullScreen(np, 1);
+			}
+		}
+		break;
+	default:
+		Debug("bad _NET_WM_STATE action: %ld", event->data.l[0]);
+		break;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleMotionNotify(const XMotionEvent *event) {
+
+	ClientNode *np;
+	Cursor cur;
+	BorderActionType action;
+
+	if(event->is_hint) {
+		return;
+	}
+
+	SetMousePosition(event->x_root, event->y_root);
+
+	np = FindClientByParent(event->window);
+	if(np && (np->state.border & BORDER_OUTLINE)) {
+		action = GetBorderActionType(np, event->x, event->y);
+		if(np->borderAction != action) {
+			np->borderAction = action;
+			cur = GetFrameCursor(action);
+			JXDefineCursor(display, np->parent, cur);
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+#ifdef USE_SHAPE
+void HandleShapeEvent(const XShapeEvent *event) {
+
+	ClientNode *np;
+
+	np = FindClientByWindow(event->window);
+	if(np) {
+		SetShape(np);
+	}
+
+}
+#endif /* USE_SHAPE */
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleColormapChange(const XColormapEvent *event) {
+	ClientNode *np;
+
+	if(event->new == True) {
+		np = FindClientByWindow(event->window);
+		if(np) {
+			np->cmap = event->colormap;
+			UpdateClientColormap(np);
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleMapRequest(const XMapEvent *event) {
+
+	ClientNode *np;
+
+	Assert(event);
+
+	if(CheckSwallowMap(event)) {
+		return;
+	}
+
+	np = FindClientByWindow(event->window);
+	if(!np) {
+		JXSync(display, False);
+		JXGrabServer(display);
+		np = AddClientWindow(event->window, 0, 1);
+		if(np) {
+			if(focusModel == FOCUS_CLICK) {
+				FocusClient(np);
+			}
+		} else {
+			JXMapWindow(display, event->window);
+		}
+		JXSync(display, False);
+		JXUngrabServer(display);
+	} else {
+		if(!(np->state.status & STAT_MAPPED)) {
+			np->state.status |= STAT_MAPPED;
+			np->state.status &= ~STAT_MINIMIZED;
+			np->state.status &= ~STAT_SDESKTOP;
+			JXMapWindow(display, np->window);
+			JXMapWindow(display, np->parent);
+			RaiseClient(np);
+			if(focusModel == FOCUS_CLICK) {
+				FocusClient(np);
+			}
+			UpdateTaskBar();
+			UpdatePager();
+		}
+	}
+	RestackClients();
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleUnmapNotify(const XUnmapEvent *event) {
+
+	ClientNode *np;
+	XEvent e;
+
+	Assert(event);
+
+	np = FindClientByWindow(event->window);
+	if(np && np->window == event->window) {
+
+		if(JXCheckTypedWindowEvent(display, np->window, DestroyNotify, &e)) {
+			HandleDestroyNotify(&e.xdestroywindow);
+			return;
+		}
+
+		if(np->controller) {
+			(np->controller)(1);
+		}
+
+		if(np->state.status & STAT_MAPPED) {
+
+			np->state.status &= ~STAT_MAPPED;
+			JXUnmapWindow(display, np->parent);
+
+			WriteState(np);
+			UpdateTaskBar();
+			UpdatePager();
+
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int HandleDestroyNotify(const XDestroyWindowEvent *event) {
+
+	ClientNode *np;
+
+	np = FindClientByWindow(event->window);
+	if(np && np->window == event->window) {
+
+		if(np->controller) {
+			(np->controller)(1);
+		}
+
+		RemoveClient(np);
+
+		return 1;
+
+	} else if(!np) {
+
+		return HandleDockDestroy(event->window);
+
+	}
+
+	return 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DispatchBorderButtonEvent(const XButtonEvent *event, ClientNode *np) {
+
+	static Time lastClickTime = 0;
+	static int lastX = 0, lastY = 0;
+	static int doubleClickActive = 0;
+	BorderActionType action;
+	int bsize;
+
+	action = GetBorderActionType(np, event->x, event->y);
+
+	switch(action & 0x0F) {
+	case BA_RESIZE:
+		if(event->type == ButtonPress) {
+			ResizeClient(np, action, event->x, event->y);
+		}
+		break;
+	case BA_MOVE:
+		if(event->type == ButtonPress) {
+			if(doubleClickActive
+				&& abs(event->time - lastClickTime) > 0
+				&& abs(event->time - lastClickTime) <= doubleClickSpeed
+				&& abs(event->x - lastX) <= doubleClickDelta
+				&& abs(event->y - lastY) <= doubleClickDelta) {
+				MaximizeClient(np);
+				doubleClickActive = 0;
+			} else {
+				if(MoveClient(np, event->x, event->y)) {
+					doubleClickActive = 0;
+				} else {
+					doubleClickActive = 1;
+					lastClickTime = event->time;
+					lastX = event->x;
+					lastY = event->y;
+				}
+			}
+		}
+		break;
+	case BA_MENU:
+		if(event->type == ButtonPress) {
+			if(np->state.border & BORDER_OUTLINE) {
+				bsize = borderWidth;
+			} else {
+				bsize = 0;
+			}
+			ShowWindowMenu(np, np->x + event->x - bsize,
+				np->y + event->y - titleHeight - bsize);
+		}
+		break;
+	case BA_CLOSE:
+		if(event->type == ButtonRelease) {
+			DeleteClient(np);
+		}
+		break;
+	case BA_MAXIMIZE:
+		if(event->type == ButtonRelease) {
+			MaximizeClient(np);
+		}
+		break;
+	case BA_MINIMIZE:
+		if(event->type == ButtonRelease) {
+			MinimizeClient(np);
+		}
+		break;
+	default:
+		break;
+	}
+
+}
+
diff --git a/src/event.h b/src/event.h
new file mode 100644
index 0000000..627442b
--- /dev/null
+++ b/src/event.h
@@ -0,0 +1,28 @@
+/**
+ * @file event.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the event functions.
+ *
+ */
+
+#ifndef EVENT_H
+#define EVENT_H
+
+/** Wait for an event and process it. */
+void WaitForEvent();
+
+/** Process an event.
+ * @param event The event to process.
+ */
+void ProcessEvent(XEvent *event);
+
+/** Discard excess motion events.
+ * @param event The event to return.
+ * @param w The window whose events to discard.
+ */
+void DiscardMotionEvents(XEvent *event, Window w);
+
+#endif
+
diff --git a/src/font.c b/src/font.c
new file mode 100644
index 0000000..8ebf19a
--- /dev/null
+++ b/src/font.c
@@ -0,0 +1,295 @@
+/****************************************************************************
+ * Functions to load fonts.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "font.h"
+#include "main.h"
+#include "error.h"
+#include "color.h"
+#include "misc.h"
+
+static const char *DEFAULT_FONT = "-*-courier-*-r-*-*-14-*-*-*-*-*-*-*";
+
+static char *fontNames[FONT_COUNT];
+
+#ifdef USE_XFT
+static XftFont *fonts[FONT_COUNT];
+#else
+static XFontStruct *fonts[FONT_COUNT];
+static GC fontGC;
+#endif
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeFonts() {
+
+	int x;
+
+	for(x = 0; x < FONT_COUNT; x++) {
+		fonts[x] = NULL;
+		fontNames[x] = NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupFonts() {
+
+#ifndef USE_XFT
+	XGCValues gcValues;
+	unsigned long gcMask;
+#endif
+	int x;
+
+	/* Inherit unset fonts from the tray for tray items. */
+	if(!fontNames[FONT_TASK]) {
+		fontNames[FONT_TASK] = CopyString(fontNames[FONT_TRAY]);
+	}
+	if(!fontNames[FONT_TRAYBUTTON]) {
+		fontNames[FONT_TRAYBUTTON] = CopyString(fontNames[FONT_TRAY]);
+	}
+	if(!fontNames[FONT_CLOCK]) {
+		fontNames[FONT_CLOCK] = CopyString(fontNames[FONT_TRAY]);
+	}
+
+#ifdef USE_XFT
+
+	for(x = 0; x < FONT_COUNT; x++) {
+		if(fontNames[x]) {
+			fonts[x] = JXftFontOpenName(display, rootScreen, fontNames[x]);
+			if(!fonts[x]) {
+				fonts[x] = JXftFontOpenXlfd(display, rootScreen, fontNames[x]);
+			}
+			if(!fonts[x]) {
+				Warning("could not load font: %s", fontNames[x]);
+			}
+		}
+		if(!fonts[x]) {
+			fonts[x] = JXftFontOpenXlfd(display, rootScreen, DEFAULT_FONT);
+		}
+		if(!fonts[x]) {
+			FatalError("could not load the default font: %s", DEFAULT_FONT);
+		}
+	}
+
+#else
+
+	for(x = 0; x < FONT_COUNT; x++) {
+		if(fontNames[x]) {
+			fonts[x] = JXLoadQueryFont(display, fontNames[x]);
+			if(!fonts[x] && fontNames[x]) {
+				Warning("could not load font: %s", fontNames[x]);
+			}
+		}
+		if(!fonts[x]) {
+			fonts[x] = JXLoadQueryFont(display, DEFAULT_FONT);
+		}
+		if(!fonts[x]) {
+			FatalError("could not load the default font: %s", DEFAULT_FONT);
+		}
+	}
+
+	gcMask = GCGraphicsExposures;
+	gcValues.graphics_exposures = False;
+	fontGC = JXCreateGC(display, rootWindow, gcMask, &gcValues);
+
+#endif
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownFonts() {
+
+	int x;
+
+	for(x = 0; x < FONT_COUNT; x++) {
+		if(fonts[x]) {
+#ifdef USE_XFT
+			JXftFontClose(display, fonts[x]);
+#else
+			JXFreeFont(display, fonts[x]);
+#endif
+			fonts[x] = NULL;
+		}
+	}
+
+#ifndef USE_XFT
+
+	JXFreeGC(display, fontGC);
+
+#endif
+
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyFonts() {
+
+	int x;
+
+	for(x = 0; x < FONT_COUNT; x++) {
+		if(fontNames[x]) {
+			Release(fontNames[x]);
+			fontNames[x] = NULL;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetStringWidth(FontType type, const char *str) {
+#ifdef USE_XFT
+
+	XGlyphInfo extents;
+	unsigned int length;
+
+	Assert(str);
+	Assert(fonts[type]);
+
+	length = strlen(str);
+
+	JXftTextExtentsUtf8(display, fonts[type], (const unsigned char*)str,
+		length, &extents);
+
+	return extents.width;
+
+#else
+
+	Assert(str);
+	Assert(fonts[type]);
+
+	return XTextWidth(fonts[type], str, strlen(str));
+
+#endif
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetStringHeight(FontType type) {
+
+	Assert(fonts[type]);
+
+	return fonts[type]->ascent + fonts[type]->descent;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetFont(FontType type, const char *value) {
+
+	if(!value) {
+		Warning("empty Font tag");
+		return;
+	}
+
+	if(fontNames[type]) {
+		Release(fontNames[type]);
+	}
+
+	fontNames[type] = CopyString(value);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void RenderString(Drawable d, FontType font, ColorType color,
+	int x, int y, int width, Region region, const char *str) {
+
+#ifdef USE_XFT
+	XftDraw *xd;
+#endif
+
+	XRectangle rect;
+	Region renderRegion;
+	int len;
+	char *output;
+
+#ifdef USE_FRIBIDI
+
+	FriBidiChar *temp;
+	FriBidiCharType type = FRIBIDI_TYPE_ON;
+	int unicodeLength;
+
+#endif
+
+	if(!str) {
+		return;
+	}
+
+	len = strlen(str);
+	if(len == 0) {
+		return;
+	}
+
+	/* Get the bounds for the string based on the specified width. */
+	rect.x = x;
+	rect.y = y;
+	rect.width = Min(GetStringWidth(font, str), width) + 2;
+	rect.height = GetStringHeight(font);
+
+	/* Create a region to use. */
+	renderRegion = XCreateRegion();
+
+	/* Combine the width bounds with the region to use. */
+	XUnionRectWithRegion(&rect, renderRegion, renderRegion);
+
+	/* Combine the provided region with the region to use. */
+	if(region) {
+		XIntersectRegion(region, renderRegion, renderRegion);
+	}
+	
+	/* Apply the bidi algorithm if requested. */
+
+#ifdef USE_FRIBIDI
+
+	temp = AllocateStack((len + 1) * sizeof(FriBidiChar));
+	unicodeLength = fribidi_utf8_to_unicode((char*)str, len, temp);
+
+	fribidi_log2vis(temp, unicodeLength, &type, temp, NULL, NULL, NULL);
+
+	fribidi_unicode_to_utf8(temp, len, (char*)temp);
+	output = (char*)temp;
+
+#else
+
+	output = (char*)str;
+
+#endif
+
+	/* Display the string. */
+
+#ifdef USE_XFT
+
+	xd = XftDrawCreate(display, d, rootVisual, rootColormap);
+	XftDrawSetClip(xd, renderRegion);
+	JXftDrawStringUtf8(xd, GetXftColor(color), fonts[font],
+		x, y + fonts[font]->ascent, (const unsigned char*)output, len);
+	XftDrawDestroy(xd);
+
+#else
+
+	JXSetForeground(display, fontGC, colors[color]);
+	XSetRegion(display, fontGC, renderRegion);
+	JXSetFont(display, fontGC, fonts[font]->fid);
+	JXDrawString(display, d, fontGC, x, y + fonts[font]->ascent, output, len);
+
+#endif
+
+	/* Free any memory used for UTF conversion. */
+
+#ifdef USE_FRIBIDI
+
+	ReleaseStack(output);
+
+#endif
+
+	XDestroyRegion(renderRegion);
+
+}
+
diff --git a/src/font.h b/src/font.h
new file mode 100644
index 0000000..fe1c0c5
--- /dev/null
+++ b/src/font.h
@@ -0,0 +1,43 @@
+/**
+ * @file font.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the font functions.
+ *
+ */
+
+#ifndef FONT_H
+#define FONT_H
+
+#include "color.h"
+
+typedef enum {
+
+	FONT_BORDER,
+	FONT_MENU,
+	FONT_TASK,
+	FONT_POPUP,
+	FONT_CLOCK,
+	FONT_TRAY,
+	FONT_TRAYBUTTON,
+
+	FONT_COUNT
+
+} FontType;
+
+void InitializeFonts();
+void StartupFonts();
+void ShutdownFonts();
+void DestroyFonts();
+
+void SetFont(FontType type, const char *value);
+
+void RenderString(Drawable d, FontType font, ColorType color,
+	int x, int y, int width, Region region, const char *str);
+
+int GetStringWidth(FontType type, const char *str);
+int GetStringHeight(FontType type);
+
+#endif
+
diff --git a/src/group.c b/src/group.c
new file mode 100644
index 0000000..cd3aba4
--- /dev/null
+++ b/src/group.c
@@ -0,0 +1,299 @@
+/****************************************************************************
+ * Functions for handling window groups.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "group.h"
+#include "client.h"
+#include "icon.h"
+#include "error.h"
+#include "match.h"
+#include "desktop.h"
+#include "main.h"
+#include "misc.h"
+
+typedef enum {
+	MATCH_NAME,
+	MATCH_CLASS
+} MatchType;
+
+typedef struct PatternListType {
+	char *pattern;
+	MatchType match;
+	struct PatternListType *next;
+} PatternListType;
+
+typedef struct OptionListType {
+	OptionType option;
+	char *value;
+	struct OptionListType *next;
+} OptionListType;
+
+typedef struct GroupType {
+	PatternListType *patterns;
+	OptionListType *options;
+	struct GroupType *next;
+} GroupType;
+
+static GroupType *groups = NULL;
+
+static void ReleasePatternList(PatternListType *lp);
+static void ReleaseOptionList(OptionListType *lp);
+static void AddPattern(PatternListType **lp, const char *pattern,
+	MatchType match);
+static void ApplyGroup(const GroupType *gp, ClientNode *np);
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeGroups() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupGroups() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownGroups() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyGroups() {
+
+	GroupType *gp;
+
+	while(groups) {
+		gp = groups->next;
+		ReleasePatternList(groups->patterns);
+		ReleaseOptionList(groups->options);
+		Release(groups);
+		groups = gp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReleasePatternList(PatternListType *lp) {
+
+	PatternListType *tp;
+
+	while(lp) {
+		tp = lp->next;
+		Release(lp->pattern);
+		Release(lp);
+		lp = tp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReleaseOptionList(OptionListType *lp) {
+
+	OptionListType *tp;
+
+	while(lp) {
+		tp = lp->next;
+		if(lp->value) {
+			Release(lp->value);
+		}
+		Release(lp);
+		lp = tp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+GroupType *CreateGroup() {
+	GroupType *tp;
+
+	tp = Allocate(sizeof(GroupType));
+	tp->patterns = NULL;
+	tp->options = NULL;
+	tp->next = groups;
+	groups = tp;
+
+	return tp;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddGroupClass(GroupType *gp, const char *pattern) {
+
+	Assert(gp);
+
+	if(pattern) {
+		AddPattern(&gp->patterns, pattern, MATCH_CLASS);
+	} else {
+		Warning("invalid group class");
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddGroupName(GroupType *gp, const char *pattern) {
+
+	Assert(gp);
+
+	if(pattern) {
+		AddPattern(&gp->patterns, pattern, MATCH_NAME);
+	} else {
+		Warning("invalid group name");
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddPattern(PatternListType **lp, const char *pattern, MatchType match) {
+
+	PatternListType *tp;
+
+	Assert(lp);
+	Assert(pattern);
+
+	tp = Allocate(sizeof(PatternListType));
+	tp->next = *lp;
+	*lp = tp;
+
+	tp->pattern = CopyString(pattern);
+	tp->match = match;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddGroupOption(GroupType *gp, OptionType option) {
+
+	OptionListType *lp;
+
+	lp = Allocate(sizeof(OptionListType));
+	lp->option = option;
+	lp->value = NULL;
+	lp->next = gp->options;
+	gp->options = lp;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddGroupOptionValue(GroupType *gp, OptionType option,
+	const char *value) {
+
+	OptionListType *lp;
+
+	Assert(value);
+
+	lp = Allocate(sizeof(OptionListType));
+	lp->option = option;
+	lp->value = CopyString(value);
+	lp->next = gp->options;
+	gp->options = lp;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ApplyGroups(ClientNode *np) {
+
+	PatternListType *lp;
+	GroupType *gp;
+
+	Assert(np);
+
+	for(gp = groups; gp; gp = gp->next) {
+		for(lp = gp->patterns; lp; lp = lp->next) {
+			if(lp->match == MATCH_CLASS) {
+				if(Match(lp->pattern, np->className)) {
+					ApplyGroup(gp, np);
+					break;
+				}
+			} else if(lp->match == MATCH_NAME) {
+				if(Match(lp->pattern, np->name)) {
+					ApplyGroup(gp, np);
+					break;
+				}
+			} else {
+				Debug("invalid match in ApplyGroups: %d", lp->match);
+			}
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ApplyGroup(const GroupType *gp, ClientNode *np) {
+
+	OptionListType *lp;
+	unsigned int temp;
+
+	Assert(gp);
+	Assert(np);
+
+	for(lp = gp->options; lp; lp = lp->next) {
+		switch(lp->option) {
+		case OPTION_STICKY:
+			np->state.status |= STAT_STICKY;
+			break;
+		case OPTION_NOLIST:
+			np->state.status |= STAT_NOLIST;
+			break;
+		case OPTION_BORDER:
+			np->state.border |= BORDER_OUTLINE;
+			break;
+		case OPTION_NOBORDER:
+			np->state.border &= ~BORDER_OUTLINE;
+			break;
+		case OPTION_TITLE:
+			np->state.border |= BORDER_TITLE;
+			break;
+		case OPTION_NOTITLE:
+			np->state.border &= ~BORDER_TITLE;
+			break;
+		case OPTION_LAYER:
+			temp = atoi(lp->value);
+			if(temp <= LAYER_COUNT) {
+				SetClientLayer(np, temp);
+			} else {
+				Warning("invalid group layer: %s", lp->value);
+			}
+			break;
+		case OPTION_DESKTOP:
+			temp = atoi(lp->value);
+			if(temp >= 1 && temp <= desktopCount) {
+				np->state.desktop = temp - 1;
+			} else {
+				Warning("invalid group desktop: %s", lp->value);
+			}
+			break;
+		case OPTION_ICON:
+			DestroyIcon(np->icon);
+			np->icon = LoadNamedIcon(lp->value);
+			break;
+		case OPTION_PIGNORE:
+			np->state.status |= STAT_PIGNORE;
+			break;
+		case OPTION_MAXIMIZED:
+			np->state.status |= STAT_MAXIMIZED;
+			break;
+		case OPTION_MINIMIZED:
+			np->state.status |= STAT_MINIMIZED;
+			break;
+		case OPTION_SHADED:
+			np->state.status |= STAT_SHADED;
+			break;
+		default:
+			Debug("invalid option: %d", lp->option);
+			break;
+		}
+	}
+
+}
+
diff --git a/src/group.h b/src/group.h
new file mode 100644
index 0000000..ccbf62f
--- /dev/null
+++ b/src/group.h
@@ -0,0 +1,48 @@
+/**
+ * @file font.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Functions for handling window groups.
+ *
+ */
+
+#ifndef GROUP_H
+#define GROUP_H
+
+struct ClientNode;
+struct GroupType;
+
+typedef enum {
+	OPTION_INVALID   = 0,
+	OPTION_STICKY    = 1,
+	OPTION_LAYER     = 2,
+	OPTION_DESKTOP   = 3,
+	OPTION_ICON      = 4,
+	OPTION_NOLIST    = 5,
+	OPTION_BORDER    = 6,
+	OPTION_NOBORDER  = 7,
+	OPTION_TITLE     = 8,
+	OPTION_NOTITLE   = 9,
+	OPTION_PIGNORE   = 10,
+	OPTION_MAXIMIZED = 11,
+	OPTION_MINIMIZED = 12,
+	OPTION_SHADED    = 13
+} OptionType;
+
+void InitializeGroups();
+void StartupGroups();
+void ShutdownGroups();
+void DestroyGroups();
+
+struct GroupType *CreateGroup();
+void AddGroupClass(struct GroupType *gp, const char *pattern);
+void AddGroupName(struct GroupType *gp, const char *pattern);
+void AddGroupOption(struct GroupType *gp, OptionType option);
+void AddGroupOptionValue(struct GroupType *gp, OptionType option,
+	const char *value);
+
+void ApplyGroups(struct ClientNode *np);
+
+#endif
+
diff --git a/src/help.c b/src/help.c
new file mode 100644
index 0000000..cdcd377
--- /dev/null
+++ b/src/help.c
@@ -0,0 +1,84 @@
+/**
+ * @file help.c
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Functions for displaying information about JWM.
+ *
+ */
+
+#include "jwm.h"
+#include "help.h"
+
+/** Display program name, version, and compiled options . */
+void DisplayAbout() {
+	printf("JWM v%s by Joe Wingbermuehle\n", PACKAGE_VERSION);
+	DisplayCompileOptions();
+}
+
+/** Display compiled options. */
+void DisplayCompileOptions() {
+
+	printf("compiled options: ");
+
+#ifndef DISABLE_CONFIRM
+	printf("confirm ");
+#endif
+
+#ifdef DEBUG
+	printf("debug ");
+#endif
+
+#ifdef USE_FRIBIDI
+	printf("fribidi ");
+#endif
+
+#ifdef USE_ICONS
+	printf("icons ");
+#endif
+
+#ifdef USE_PNG
+	printf("png ");
+#endif
+
+#ifdef USE_SHAPE
+	printf("shape ");
+#endif
+
+#ifdef USE_XFT
+	printf("xft ");
+#endif
+
+#ifdef USE_XINERAMA
+	printf("xinerama ");
+#endif
+
+#ifdef USE_XPM
+	printf("xpm ");
+#endif
+
+#ifdef USE_XRENDER
+	printf("xrender ");
+#endif
+
+	printf("\nsystem configuration: %s\n", SYSTEM_CONFIG);
+
+}
+
+/** Display all help. */
+void DisplayHelp() {
+	DisplayUsage();
+	printf("  -display X  Set the X display to use\n");
+	printf("  -exit       Exit JWM (send _JWM_EXIT to the root)\n");
+	printf("  -h          Display this help message\n");
+	printf("  -p          Parse the configuration file and exit\n");
+	printf("  -restart    Restart JWM (send _JWM_RESTART to the root)\n");
+	printf("  -v          Display version information\n");
+}
+
+/** Display program usage information. */
+void DisplayUsage() {
+	DisplayAbout();
+	printf("usage: jwm [ options ]\n");
+}
+
diff --git a/src/help.h b/src/help.h
new file mode 100644
index 0000000..dca2f75
--- /dev/null
+++ b/src/help.h
@@ -0,0 +1,26 @@
+/**
+ * @file help.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the help functions.
+ *
+ */
+
+#ifndef HELP_H
+#define HELP_H
+
+/** Display program name, version, and compiled options . */
+void DisplayAbout();
+
+/** Display compiled options. */
+void DisplayCompileOptions();
+
+/** Display all help. */
+void DisplayHelp();
+
+/** Display program usage information. */
+void DisplayUsage();
+
+#endif
+
diff --git a/src/hint.c b/src/hint.c
new file mode 100644
index 0000000..6ab096b
--- /dev/null
+++ b/src/hint.c
@@ -0,0 +1,970 @@
+/****************************************************************************
+ * Functions to handle hints.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "hint.h"
+#include "client.h"
+#include "main.h"
+#include "tray.h"
+#include "desktop.h"
+#include "misc.h"
+
+/* MWM Defines */
+#define MWM_HINTS_FUNCTIONS   (1L << 0)
+#define MWM_HINTS_DECORATIONS (1L << 1)
+#define MWM_HINTS_INPUT_MODE  (1L << 2)
+#define MWM_HINTS_STATUS      (1L << 3)
+
+#define MWM_FUNC_ALL      (1L << 0)
+#define MWM_FUNC_RESIZE   (1L << 1)
+#define MWM_FUNC_MOVE     (1L << 2)
+#define MWM_FUNC_MINIMIZE (1L << 3)
+#define MWM_FUNC_MAXIMIZE (1L << 4)
+#define MWM_FUNC_CLOSE    (1L << 5)
+
+#define MWM_DECOR_ALL      (1L << 0)
+#define MWM_DECOR_BORDER   (1L << 1)
+#define MWM_DECOR_RESIZEH  (1L << 2)
+#define MWM_DECOR_TITLE    (1L << 3)
+#define MWM_DECOR_MENU     (1L << 4)
+#define MWM_DECOR_MINIMIZE (1L << 5)
+#define MWM_DECOR_MAXIMIZE (1L << 6)
+
+#define MWM_INPUT_MODELESS                  0
+#define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
+#define MWM_INPUT_SYSTEM_MODAL              2
+#define MWM_INPUT_FULL_APPLICATION_MODAL    3
+
+#define MWM_TEAROFF_WINDOW (1L << 0)
+
+typedef struct {
+
+	unsigned long flags;
+	unsigned long functions;
+	unsigned long decorations;
+	long          inputMode;
+	unsigned long status;
+
+} PropMwmHints;
+
+typedef struct {
+	Atom *atom;
+	const char *name;
+} ProtocolNode;
+
+typedef struct {
+	Atom *atom;
+	const char *name;
+} AtomNode;
+
+Atom atoms[ATOM_COUNT];
+
+static const AtomNode atomList[] = {
+
+	{ &atoms[ATOM_COMPOUND_TEXT],             "COMPOUND_TEXT"               },
+	{ &atoms[ATOM_UTF8_STRING],               "UTF8_STRING"                 },
+
+	{ &atoms[ATOM_WM_STATE],                  "WM_STATE"                    },
+	{ &atoms[ATOM_WM_PROTOCOLS],              "WM_PROTOCOLS"                },
+	{ &atoms[ATOM_WM_DELETE_WINDOW],          "WM_DELETE_WINDOW"            },
+	{ &atoms[ATOM_WM_TAKE_FOCUS],             "WM_TAKE_FOCUS"               },
+	{ &atoms[ATOM_WM_LOCALE_NAME],            "WM_LOCALE_NAME"              },
+	{ &atoms[ATOM_WM_CHANGE_STATE],           "WM_CHANGE_STATE"             },
+	{ &atoms[ATOM_WM_COLORMAP_WINDOWS],       "WM_COLORMAP_WINDOWS"         },
+
+	{ &atoms[ATOM_NET_SUPPORTED],             "_NET_SUPPORTED"              },
+	{ &atoms[ATOM_NET_NUMBER_OF_DESKTOPS],    "_NET_NUMBER_OF_DESKTOPS"     },
+	{ &atoms[ATOM_NET_DESKTOP_NAMES],         "_NET_DESKTOP_NAMES"          },
+	{ &atoms[ATOM_NET_DESKTOP_GEOMETRY],      "_NET_DESKTOP_GEOMETRY"       },
+	{ &atoms[ATOM_NET_DESKTOP_VIEWPORT],      "_NET_DESKTOP_VIEWPORT"       },
+	{ &atoms[ATOM_NET_CURRENT_DESKTOP],       "_NET_CURRENT_DESKTOP"        },
+	{ &atoms[ATOM_NET_ACTIVE_WINDOW],         "_NET_ACTIVE_WINDOW"          },
+	{ &atoms[ATOM_NET_WORKAREA],              "_NET_WORKAREA"               },
+	{ &atoms[ATOM_NET_SUPPORTING_WM_CHECK],   "_NET_SUPPORTING_WM_CHECK"    },
+	{ &atoms[ATOM_NET_FRAME_EXTENTS],         "_NET_FRAME_EXTENTS"          },
+	{ &atoms[ATOM_NET_WM_DESKTOP],            "_NET_WM_DESKTOP"             },
+	{ &atoms[ATOM_NET_WM_STATE],              "_NET_WM_STATE"               },
+	{ &atoms[ATOM_NET_WM_STATE_STICKY],       "_NET_WM_STATE_STICKY"        },
+	{ &atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT], "_NET_WM_STATE_MAXIMIZED_VERT"},
+	{ &atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ], "_NET_WM_STATE_MAXIMIZED_HORZ"},
+	{ &atoms[ATOM_NET_WM_STATE_SHADED],       "_NET_WM_STATE_SHADED"        },
+	{ &atoms[ATOM_NET_WM_STATE_FULLSCREEN],   "_NET_WM_STATE_FULLSCREEN"    },
+	{ &atoms[ATOM_NET_WM_ALLOWED_ACTIONS],    "_NET_WM_ALLOWED_ACTIONS"     },
+	{ &atoms[ATOM_NET_WM_ACTION_MOVE],        "_NET_WM_ACTION_MOVE"         },
+	{ &atoms[ATOM_NET_WM_ACTION_RESIZE],      "_NET_WM_ACTION_RESIZE"       },
+	{ &atoms[ATOM_NET_WM_ACTION_MINIMIZE],    "_NET_WM_ACTION_MINIMIZE"     },
+	{ &atoms[ATOM_NET_WM_ACTION_SHADE],       "_NET_WM_ACTION_SHADE"        },
+	{ &atoms[ATOM_NET_WM_ACTION_STICK],       "_NET_WM_ACTION_STICK"        },
+	{ &atoms[ATOM_NET_WM_ACTION_MAXIMIZE_HORZ], "_NET_WM_ACTION_MAXIMIZE_HORZ"},
+	{ &atoms[ATOM_NET_WM_ACTION_MAXIMIZE_VERT], "_NET_WM_ACTION_MAXIMIZE_VERT"},
+	{ &atoms[ATOM_NET_WM_ACTION_CHANGE_DESKTOP],
+		"_NET_WM_ACTION_CHANGE_DESKTOP"},
+	{ &atoms[ATOM_NET_WM_ACTION_CLOSE],       "_NET_WM_ACTION_CLOSE"        },
+	{ &atoms[ATOM_NET_CLOSE_WINDOW],          "_NET_CLOSE_WINDOW"           },
+	{ &atoms[ATOM_NET_MOVERESIZE_WINDOW],     "_NET_MOVERESIZE_WINDOW"      },
+	{ &atoms[ATOM_NET_WM_NAME],               "_NET_WM_NAME"                },
+	{ &atoms[ATOM_NET_WM_ICON],               "_NET_WM_ICON"                },
+	{ &atoms[ATOM_NET_WM_WINDOW_TYPE],        "_NET_WM_WINDOW_TYPE"         },
+	{ &atoms[ATOM_NET_WM_WINDOW_TYPE_DESKTOP],"_NET_WM_WINDOW_TYPE_DESKTOP" },
+	{ &atoms[ATOM_NET_WM_WINDOW_TYPE_DOCK],   "_NET_WM_WINDOW_TYPE_DOCK"    },
+	{ &atoms[ATOM_NET_CLIENT_LIST],           "_NET_CLIENT_LIST"            },
+	{ &atoms[ATOM_NET_CLIENT_LIST_STACKING],  "_NET_CLIENT_LIST_STACKING"   },
+	{ &atoms[ATOM_NET_WM_STRUT_PARTIAL],      "_NET_WM_STRUT_PARTIAL"       },
+	{ &atoms[ATOM_NET_WM_STRUT],              "_NET_WM_STRUT"               },
+	{ &atoms[ATOM_NET_SYSTEM_TRAY_OPCODE],    "_NET_SYSTEM_TRAY_OPCODE"     },
+
+	{ &atoms[ATOM_WIN_LAYER],                 "_WIN_LAYER"                  },
+	{ &atoms[ATOM_WIN_STATE],                 "_WIN_STATE"                  },
+	{ &atoms[ATOM_WIN_WORKSPACE],             "_WIN_WORKSPACE"              },
+	{ &atoms[ATOM_WIN_WORKSPACE_COUNT],       "_WIN_WORKSPACE_COUNT"        },
+	{ &atoms[ATOM_WIN_SUPPORTING_WM_CHECK],   "_WIN_SUPPORTING_WM_CHECK"    },
+	{ &atoms[ATOM_WIN_PROTOCOLS],             "_WIN_PROTOCOLS"              },
+
+	{ &atoms[ATOM_MOTIF_WM_HINTS],            "_MOTIF_WM_HINTS"             },
+
+	{ &atoms[ATOM_JWM_RESTART],               "_JWM_RESTART"                },
+	{ &atoms[ATOM_JWM_EXIT],                  "_JWM_EXIT"                   }
+
+};
+
+static void WriteNetState(ClientNode *np);
+static void WriteNetAllowed(ClientNode *np);
+static void WriteWinState(ClientNode *np);
+static void ReadWMHints(Window win, ClientState *state);
+static void ReadMotifHints(Window win, ClientState *state);
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeHints() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupHints() {
+
+	unsigned long array[128];
+	Atom supported[ATOM_COUNT];
+	Window win;
+	char *data;
+	unsigned int x;
+	unsigned int count;
+
+	/* Intern the atoms */
+	for(x = 0; x < ATOM_COUNT; x++) {
+		*atomList[x].atom = JXInternAtom(display, atomList[x].name, False);
+	}
+
+	/* _NET_SUPPORTED */
+	for(x = FIRST_NET_ATOM; x <= LAST_NET_ATOM; x++) {
+		supported[x - FIRST_NET_ATOM] = atoms[x];
+	}
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_SUPPORTED],
+		XA_ATOM, 32, PropModeReplace, (unsigned char*)supported,
+		LAST_NET_ATOM - FIRST_NET_ATOM + 1);
+
+	/* _WIN_PROTOCOLS */
+	for(x = FIRST_WIN_ATOM; x <= LAST_WIN_ATOM; x++) {
+		supported[x - FIRST_WIN_ATOM] = atoms[x];
+	}
+	JXChangeProperty(display, rootWindow, atoms[ATOM_WIN_PROTOCOLS],
+		XA_ATOM, 32, PropModeReplace, (unsigned char*)supported,
+		LAST_WIN_ATOM - FIRST_WIN_ATOM + 1);
+
+	/* _NET_NUMBER_OF_DESKTOPS */
+	SetCardinalAtom(rootWindow, ATOM_NET_NUMBER_OF_DESKTOPS, desktopCount);
+
+	/* _NET_DESKTOP_NAMES */
+	count = 0;
+	for(x = 0; x < desktopCount; x++) {
+		count += strlen(desktopNames[x]) + 1;
+	}
+	data = AllocateStack(count);
+	count = 0;
+	for(x = 0; x < desktopCount; x++) {
+		strcpy(data + count, desktopNames[x]);
+		count += strlen(desktopNames[x]) + 1;
+	}
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_DESKTOP_NAMES],
+		atoms[ATOM_UTF8_STRING], 8, PropModeReplace,
+		(unsigned char*)data, count);
+	ReleaseStack(data);
+
+	/* _NET_DESKTOP_GEOMETRY */
+	array[0] = rootWidth;
+	array[1] = rootHeight;
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_DESKTOP_GEOMETRY],
+		XA_CARDINAL, 32, PropModeReplace,
+		(unsigned char*)array, 2);
+
+	/* _NET_DESKTOP_VIEWPORT */
+	array[0] = 0;
+	array[1] = 0;
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_DESKTOP_VIEWPORT],
+		XA_CARDINAL, 32, PropModeReplace,
+		(unsigned char*)array, 2);
+
+	/* _NET_WORKAREA */
+	for(x = 0; x < desktopCount; x++) {
+		array[x * 4 + 0] = 0;
+		array[x * 4 + 1] = 0;
+		array[x * 4 + 2] = rootWidth;
+		array[x * 4 + 3] = rootHeight;
+	}
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_WORKAREA],
+		XA_CARDINAL, 32, PropModeReplace,
+		(unsigned char*)array, desktopCount * 4);
+
+	win = GetSupportingWindow();
+	JXChangeProperty(display, win, atoms[ATOM_NET_WM_NAME],
+		atoms[ATOM_UTF8_STRING], 8, PropModeReplace,
+		(unsigned char*)"JWM", 3);
+
+	SetWindowAtom(rootWindow, ATOM_NET_SUPPORTING_WM_CHECK, win);
+	SetWindowAtom(win, ATOM_NET_SUPPORTING_WM_CHECK, win);
+
+	SetWindowAtom(rootWindow, ATOM_WIN_SUPPORTING_WM_CHECK, win);
+	SetWindowAtom(win, ATOM_WIN_SUPPORTING_WM_CHECK, win);
+
+	SetCardinalAtom(rootWindow, ATOM_WIN_WORKSPACE_COUNT, desktopCount);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownHints() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyHints() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadCurrentDesktop() {
+
+	unsigned long temp;
+
+	currentDesktop = 0;
+
+	if(GetCardinalAtom(rootWindow, ATOM_NET_CURRENT_DESKTOP, &temp)) {
+		ChangeDesktop(temp);
+	} else if(GetCardinalAtom(rootWindow, ATOM_WIN_WORKSPACE, &temp)) {
+		ChangeDesktop(temp);
+	} else {
+		ChangeDesktop(0);
+	}
+
+}
+
+/****************************************************************************
+ * Read client protocls/hints.
+ * This is called while the client is being added to management.
+ ****************************************************************************/
+void ReadClientProtocols(ClientNode *np) {
+
+	Status status;
+	ClientNode *pp;
+
+	Assert(np);
+
+	ReadWMName(np);
+	ReadWMClass(np);
+	ReadWMNormalHints(np);
+	ReadWMColormaps(np);
+
+	status = JXGetTransientForHint(display, np->window, &np->owner);
+	if(!status) {
+		np->owner = None;
+	}
+
+	np->state = ReadWindowState(np->window);
+	if(np->minWidth == np->maxWidth && np->minHeight == np->maxHeight) {
+		np->state.border &= ~BORDER_RESIZE;
+	}
+
+	/* Set the client to the same layer as its owner. */
+	if(np->owner != None) {
+		pp = FindClientByWindow(np->owner);
+		if(pp) {
+			np->state.layer = pp->state.layer;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void WriteState(ClientNode *np) {
+
+	unsigned long data[2];
+
+	Assert(np);
+
+	if(np->state.status & STAT_MAPPED) {
+		data[0] = NormalState;
+	} else if(np->state.status & STAT_MINIMIZED) {
+		data[0] = IconicState;
+	} else {
+		data[0] = WithdrawnState;
+	}
+	data[1] = None;
+
+	JXChangeProperty(display, np->window, atoms[ATOM_WM_STATE],
+		atoms[ATOM_WM_STATE], 32, PropModeReplace,
+		(unsigned char*)data, 2);
+
+	WriteNetState(np);
+	WriteNetAllowed(np);
+	WriteWinState(np);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void WriteNetState(ClientNode *np) {
+
+	unsigned long values[5];
+	int north, south, east, west;
+	int index;
+
+	Assert(np);
+
+	index = 0;
+
+	if(np->state.status & STAT_MAXIMIZED) {
+		values[index++] = atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT];
+		values[index++] = atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ];
+	}
+
+	if(np->state.status & STAT_SHADED) {
+		values[index++] = atoms[ATOM_NET_WM_STATE_SHADED];
+	}
+
+	if(np->state.status & STAT_STICKY) {
+		values[index++] = atoms[ATOM_NET_WM_STATE_STICKY];
+	}
+
+	if(np->state.status & STAT_FULLSCREEN) {
+		values[index++] = atoms[ATOM_NET_WM_STATE_FULLSCREEN];
+	}
+
+	JXChangeProperty(display, np->window, atoms[ATOM_NET_WM_STATE],
+		XA_ATOM, 32, PropModeReplace, (unsigned char*)values, index);
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	/* left, right, top, bottom */
+	values[0] = west;
+	values[1] = east;
+	values[2] = north;
+	values[3] = south;
+
+	JXChangeProperty(display, np->window, atoms[ATOM_NET_FRAME_EXTENTS],
+		XA_CARDINAL, 32, PropModeReplace, (unsigned char*)values, 4);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void WriteNetAllowed(ClientNode *np) {
+
+	unsigned long values[10];
+	int index;
+
+	Assert(np);
+
+	index = 0;
+
+	if(np->state.border & BORDER_TITLE) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_SHADE];
+	}
+
+	if(np->state.border & BORDER_MIN) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_MINIMIZE];
+	}
+
+	if(np->state.border & BORDER_MAX) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_MAXIMIZE_HORZ];
+		values[index++] = atoms[ATOM_NET_WM_ACTION_MAXIMIZE_VERT];
+	}
+
+	if(np->state.border & BORDER_CLOSE) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_CLOSE];
+	}
+
+	if(np->state.border & BORDER_RESIZE) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_RESIZE];
+	}
+
+	if(np->state.border & BORDER_MOVE) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_MOVE];
+	}
+
+	if(!(np->state.status & STAT_STICKY)) {
+		values[index++] = atoms[ATOM_NET_WM_ACTION_CHANGE_DESKTOP];
+	}
+
+	values[index++] = atoms[ATOM_NET_WM_ACTION_STICK];
+
+	JXChangeProperty(display, np->window, atoms[ATOM_NET_WM_ALLOWED_ACTIONS],
+		XA_ATOM, 32, PropModeReplace, (unsigned char*)values, index);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void WriteWinState(ClientNode *np) {
+
+	unsigned long flags;
+
+	Assert(np);
+
+	flags = 0;
+	if(np->state.status & STAT_STICKY) {
+		flags |= WIN_STATE_STICKY;
+	}
+	if(np->state.status & STAT_MINIMIZED) {
+		flags |= WIN_STATE_MINIMIZED;
+	}
+	if(np->state.status & STAT_MAXIMIZED) {
+		flags |= WIN_STATE_MAXIMIZED_VERT;
+		flags |= WIN_STATE_MAXIMIZED_HORIZ;
+	}
+	if(np->state.status & STAT_NOLIST) {
+		flags |= WIN_STATE_HIDDEN;
+	}
+	if(np->state.status & STAT_SHADED) {
+		flags |= WIN_STATE_SHADED;
+	}
+
+	SetCardinalAtom(np->window, ATOM_WIN_STATE, flags);
+
+}
+
+/****************************************************************************
+ * Read all hints needed to determine the current window state.
+ ****************************************************************************/
+ClientState ReadWindowState(Window win) {
+
+	ClientState result;
+	Status status;
+	unsigned long count, x;
+	unsigned long extra;
+	Atom realType;
+	int realFormat;
+	unsigned char *temp;
+	Atom *state;
+	unsigned long card;
+	int maxVert, maxHorz;
+	int fullScreen;
+
+	Assert(win != None);
+
+	result.status = STAT_NONE;
+	result.border = BORDER_DEFAULT;
+	result.layer = LAYER_NORMAL;
+	result.desktop = currentDesktop;
+
+	ReadWMHints(win, &result);
+	ReadMotifHints(win, &result);
+
+	/* _NET_WM_DESKTOP */
+	if(GetCardinalAtom(win, ATOM_NET_WM_DESKTOP, &card)) {
+		if(card == ~0UL) {
+			result.status |= STAT_STICKY;
+		} else if(card < desktopCount) {
+			result.desktop = card;
+		} else {
+			result.desktop = desktopCount - 1;
+		}
+	}
+
+	/* _NET_WM_STATE */
+	status = JXGetWindowProperty(display, win,
+		atoms[ATOM_NET_WM_STATE], 0, 32, False, XA_ATOM, &realType,
+		&realFormat, &count, &extra, &temp);
+	if(status == Success) {
+		if(count > 0) {
+			maxVert = 0;
+			maxHorz = 0;
+			fullScreen = 0;
+			state = (unsigned long*)temp;
+			for(x = 0; x < count; x++) {
+				if(state[x] == atoms[ATOM_NET_WM_STATE_STICKY]) {
+					result.status |= STAT_STICKY;
+				} else if(state[x] == atoms[ATOM_NET_WM_STATE_SHADED]) {
+					result.status |= STAT_SHADED;
+				} else if(state[x] == atoms[ATOM_NET_WM_STATE_MAXIMIZED_VERT]) {
+					maxVert = 1;
+				} else if(state[x] == atoms[ATOM_NET_WM_STATE_MAXIMIZED_HORZ]) {
+					maxHorz = 1;
+				} else if(state[x] == atoms[ATOM_NET_WM_STATE_FULLSCREEN]) {
+					fullScreen = 1;
+				}
+			}
+			if(maxVert && maxHorz) {
+				result.status |= STAT_MAXIMIZED;
+			}
+			if(fullScreen) {
+				result.status |= STAT_FULLSCREEN;
+			}
+		}
+		if(temp) {
+			JXFree(temp);
+		}
+	}
+
+	/* _NET_WM_WINDOW_TYPE */
+	status = JXGetWindowProperty(display, win,
+		atoms[ATOM_NET_WM_WINDOW_TYPE], 0, 32, False, XA_ATOM, &realType,
+		&realFormat, &count, &extra, &temp);
+	if(status == Success) {
+		if(count > 0) {
+			state = (unsigned long*)temp;
+			for(x = 0; x < count; x++) {
+				if(state[x] == atoms[ATOM_NET_WM_WINDOW_TYPE_DESKTOP]) {
+					result.status |= STAT_STICKY | STAT_NOLIST;
+					result.layer = 0;
+					result.border = BORDER_NONE;
+				} else if(state[x] == atoms[ATOM_NET_WM_WINDOW_TYPE_DOCK]) {
+					result.status |= STAT_STICKY | STAT_NOLIST;
+					result.layer = 0;
+					result.border = BORDER_NONE;
+				}
+			}
+		}
+		if(temp) {
+			JXFree(temp);
+		}
+	}
+
+	/* _WIN_STATE */
+	if(GetCardinalAtom(win, ATOM_WIN_STATE, &card)) {
+		if(card & WIN_STATE_STICKY) {
+			result.status |= STAT_STICKY;
+		}
+		if(card & WIN_STATE_MINIMIZED) {
+			result.status |= STAT_MINIMIZED;
+		}
+		if(card & WIN_STATE_HIDDEN) {
+			result.status |= STAT_NOLIST;
+		}
+		if(card & WIN_STATE_SHADED) {
+			result.status |= STAT_SHADED;
+		}
+		if((card & WIN_STATE_MAXIMIZED_VERT)
+			&& (card & WIN_STATE_MAXIMIZED_HORIZ)) {
+			result.status |= STAT_MAXIMIZED;
+		}
+	}
+
+	/* _WIN_LAYER */
+	if(GetCardinalAtom(win, ATOM_WIN_LAYER, &card)) {
+		result.layer = card;
+	}
+
+	return result;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadWMName(ClientNode *np) {
+
+	unsigned long count;
+	int status;
+	unsigned long extra;
+	Atom realType;
+	int realFormat;
+	unsigned char *name;
+
+	Assert(np);
+
+	if(np->name) {
+		JXFree(np->name);
+	}
+
+	status = JXGetWindowProperty(display, np->window,
+		atoms[ATOM_NET_WM_NAME], 0, 1024, False,
+		atoms[ATOM_UTF8_STRING], &realType, &realFormat, &count, &extra, &name);
+	if(status != Success) {
+		np->name = NULL;
+	} else {
+		np->name = (char*)name;
+	}
+
+	if(!np->name) {
+		if(JXFetchName(display, np->window, &np->name) == 0) {
+			np->name = NULL;
+		}
+	}
+
+	if(!np->name) {
+		status = JXGetWindowProperty(display, np->window, XA_WM_NAME,
+			0, 1024, False, atoms[ATOM_COMPOUND_TEXT], &realType,
+			&realFormat, &count, &extra, &name);
+		if(status != Success) {
+			np->name = NULL;
+		} else {
+			np->name = (char*)name;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadWMClass(ClientNode *np) {
+
+	XClassHint hint;
+
+	Assert(np);
+
+	if(JXGetClassHint(display, np->window, &hint)) {
+		np->instanceName = hint.res_name;
+		np->className = hint.res_class;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+ClientProtocolType ReadWMProtocols(Window w) {
+
+	ClientProtocolType result;
+	unsigned long count, x;
+	int status;
+	unsigned long extra;
+	Atom realType;
+	int realFormat;
+	unsigned char *temp;
+	Atom *p;
+
+	Assert(w != None);
+
+	result = PROT_NONE;
+	status = JXGetWindowProperty(display, w, atoms[ATOM_WM_PROTOCOLS],
+		0, 32, False, XA_ATOM, &realType, &realFormat, &count, &extra, &temp);
+	p = (Atom*)temp;
+
+	if(status != Success || !p) {
+		return result;
+	}
+
+	for(x = 0; x < count; x++) {
+		if(p[x] == atoms[ATOM_WM_DELETE_WINDOW]) {
+			result |= PROT_DELETE;
+		} else if(p[x] == atoms[ATOM_WM_TAKE_FOCUS]) {
+			result |= PROT_TAKE_FOCUS;
+		}
+	}
+
+	JXFree(p);
+
+	return result;
+	
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadWMNormalHints(ClientNode *np) {
+
+	XSizeHints hints;
+	long temp;
+
+	Assert(np);
+
+	if(!JXGetWMNormalHints(display, np->window, &hints, &temp)) {
+		np->sizeFlags = 0;
+	} else {
+		np->sizeFlags = hints.flags;
+	}
+
+	if(np->sizeFlags & PResizeInc) {
+		np->xinc = Max(1, hints.width_inc);
+		np->yinc = Max(1, hints.height_inc);
+	} else {
+		np->xinc = 1;
+		np->yinc = 1;
+	}
+
+	if(np->sizeFlags & PMinSize) {
+		np->minWidth = Max(0, hints.min_width);
+		np->minHeight = Max(0, hints.min_height);
+	} else {
+		np->minWidth = 1;
+		np->minHeight = 1;
+	}
+
+	if(np->sizeFlags & PMaxSize) {
+		np->maxWidth =  hints.max_width;
+		np->maxHeight = hints.max_height;
+		if(np->maxWidth <= 0) {
+			np->maxWidth = rootWidth;
+		}
+		if(np->maxHeight <= 0) {
+			np->maxHeight = rootHeight;
+		}
+	} else {
+		np->maxWidth = rootWidth;
+		np->maxHeight = rootHeight;
+	}
+
+	if(np->sizeFlags & PBaseSize) {
+		np->baseWidth = hints.base_width;
+		np->baseHeight = hints.base_height;
+	} else if(np->sizeFlags & PMinSize) {
+		np->baseWidth = np->minWidth;
+		np->baseHeight = np->minHeight;
+	} else {
+		np->baseWidth = 0;
+		np->baseHeight = 0;
+	}
+
+	if(np->sizeFlags & PAspect) {
+		np->aspect.minx = hints.min_aspect.x;
+		np->aspect.miny = hints.min_aspect.y;
+		np->aspect.maxx = hints.max_aspect.x;
+		np->aspect.maxy = hints.max_aspect.y;
+		if(np->aspect.minx < 1) {
+			np->aspect.minx = 1;
+		}
+		if(np->aspect.miny < 1) {
+			np->aspect.miny = 1;
+		}
+		if(np->aspect.maxx < 1) {
+			np->aspect.maxx = 1;
+		}
+		if(np->aspect.maxy < 1) {
+			np->aspect.maxy = 1;
+		}
+	}
+
+	if(np->sizeFlags & PWinGravity) {
+		np->gravity = hints.win_gravity;
+	} else {
+		np->gravity = 1;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadWMColormaps(ClientNode *np) {
+
+	Window *windows;
+	ColormapNode *cp;
+	int count;
+	int x;
+
+	Assert(np);
+
+	if(JXGetWMColormapWindows(display, np->window, &windows, &count)) {
+		if(count > 0) {
+
+			/* Free old colormaps. */
+			while(np->colormaps) {
+				cp = np->colormaps->next;
+				Release(np->colormaps);
+				np->colormaps = cp;
+			}
+
+			/* Put the maps in the list in order so they will come out in
+			 * reverse order. This way they will be installed with the
+			 * most important last.
+			 * Keep track of at most colormapCount colormaps for each
+			 * window to avoid doing extra work. */
+			count = Min(colormapCount, count);
+			for(x = 0; x < count; x++) {
+				cp = Allocate(sizeof(ColormapNode));
+				cp->window = windows[x];
+				cp->next = np->colormaps;
+				np->colormaps = cp;
+			}
+
+			JXFree(windows);
+
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadWMHints(Window win, ClientState *state) {
+
+	XWMHints *wmhints;
+
+	Assert(win != None);
+	Assert(state);
+
+	wmhints = JXGetWMHints(display, win);
+	if(wmhints) {
+		switch(wmhints->flags & StateHint) {
+		case IconicState:
+			state->status |= STAT_MINIMIZED;
+			break;
+		default:
+			if(!(state->status & STAT_MINIMIZED)) {
+				state->status |= STAT_MAPPED;
+			}
+			break;
+		}
+		JXFree(wmhints);
+	} else {
+		state->status |= STAT_MAPPED;
+	}
+
+}
+
+/****************************************************************************
+ * Read _MOTIF_WM_HINTS
+ ****************************************************************************/
+void ReadMotifHints(Window win, ClientState *state) {
+
+	PropMwmHints *mhints;
+	Atom type;
+	unsigned long itemCount, bytesLeft;
+	unsigned char *data;
+	int format;
+
+	Assert(win != None);
+	Assert(state);
+
+	if(JXGetWindowProperty(display, win, atoms[ATOM_MOTIF_WM_HINTS],
+		0L, 20L, False, atoms[ATOM_MOTIF_WM_HINTS], &type, &format,
+		&itemCount, &bytesLeft, &data) != Success) {
+		return;
+	}
+
+	mhints = (PropMwmHints*)data;
+	if(mhints) {
+
+		if((mhints->flags & MWM_HINTS_FUNCTIONS)
+			&& !(mhints->functions & MWM_FUNC_ALL)) {
+
+			if(!(mhints->functions & MWM_FUNC_RESIZE)) {
+				state->border &= ~BORDER_RESIZE;
+			}
+			if(!(mhints->functions & MWM_FUNC_MOVE)) {
+				state->border &= ~BORDER_MOVE;
+			}
+			if(!(mhints->functions & MWM_FUNC_MINIMIZE)) {
+				state->border &= ~BORDER_MIN;
+			}
+			if(!(mhints->functions & MWM_FUNC_MAXIMIZE)) {
+				state->border &= ~BORDER_MAX;
+			}
+			if(!(mhints->functions & MWM_FUNC_CLOSE)) {
+				state->border &= ~BORDER_CLOSE;
+			}
+		}
+
+		if((mhints->flags & MWM_HINTS_DECORATIONS)
+			&& !(mhints->decorations & MWM_DECOR_ALL)) {
+
+			if(!(mhints->decorations & MWM_DECOR_BORDER)) {
+				state->border &= ~BORDER_OUTLINE;
+			}
+			if(!(mhints->decorations & MWM_DECOR_TITLE)) {
+				state->border &= ~BORDER_TITLE;
+			}
+			if(!(mhints->decorations & MWM_DECOR_MINIMIZE)) {
+				state->border &= ~BORDER_MIN;
+			}
+			if(!(mhints->decorations & MWM_DECOR_MAXIMIZE)) {
+				state->border &= ~BORDER_MAX;
+			}
+		}
+
+		JXFree(mhints);
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetCardinalAtom(Window window, AtomType atom, unsigned long *value) {
+
+	unsigned long count;
+	int status;
+	unsigned long extra;
+	Atom realType;
+	int realFormat;
+	unsigned char *data;
+	int ret;
+
+	Assert(window != None);
+	Assert(value);
+
+	status = JXGetWindowProperty(display, window, atoms[atom], 0, 1, False,
+		XA_CARDINAL, &realType, &realFormat, &count, &extra, &data);
+
+	ret = 0;
+	if(status == Success && data) {
+		if(count == 1) {
+			*value = *(unsigned long*)data;
+			ret = 1;
+		}
+		JXFree(data);
+	}
+
+	return ret;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetWindowAtom(Window window, AtomType atom, Window *value) {
+	unsigned long count;
+	int status;
+	unsigned long extra;
+	Atom realType;
+	int realFormat;
+	unsigned char *data;
+	int ret;
+
+	Assert(window != None);
+	Assert(value);
+
+	status = JXGetWindowProperty(display, window, atoms[atom], 0, 1, False,
+		XA_WINDOW, &realType, &realFormat, &count, &extra, &data);
+
+	ret = 0;
+	if(status == Success && data) {
+		if(count == 1) {
+			*value = *(Window*)data;
+			ret = 1;
+		}
+		JXFree(data);
+	}
+
+	return ret;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetCardinalAtom(Window window, AtomType atom, unsigned long value) {
+
+	Assert(window != None);
+
+	JXChangeProperty(display, window, atoms[atom], XA_CARDINAL, 32,
+		PropModeReplace, (unsigned char*)&value, 1);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetWindowAtom(Window window, AtomType atom, unsigned long value) {
+
+	Assert(window != None);
+
+	JXChangeProperty(display, window, atoms[atom], XA_WINDOW, 32,
+		PropModeReplace, (unsigned char*)&value, 1);
+
+}
+
+
diff --git a/src/hint.h b/src/hint.h
new file mode 100644
index 0000000..7eae815
--- /dev/null
+++ b/src/hint.h
@@ -0,0 +1,173 @@
+/**
+ * @file hint.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for reading and writing X properties.
+ *
+ */
+
+#ifndef HINT_H
+#define HINT_H
+
+struct ClientNode;
+
+typedef enum {
+
+	/* Misc */
+	ATOM_COMPOUND_TEXT,
+	ATOM_UTF8_STRING,
+
+	/* Standard atoms */
+	ATOM_WM_STATE,
+	ATOM_WM_PROTOCOLS,
+	ATOM_WM_DELETE_WINDOW,
+	ATOM_WM_TAKE_FOCUS,
+	ATOM_WM_LOCALE_NAME,
+	ATOM_WM_CHANGE_STATE,
+	ATOM_WM_COLORMAP_WINDOWS,
+
+	/* WM Spec atoms */
+	ATOM_NET_SUPPORTED,
+	ATOM_NET_NUMBER_OF_DESKTOPS,
+	ATOM_NET_DESKTOP_NAMES,
+	ATOM_NET_DESKTOP_GEOMETRY,
+	ATOM_NET_DESKTOP_VIEWPORT,
+	ATOM_NET_CURRENT_DESKTOP,
+	ATOM_NET_ACTIVE_WINDOW,
+	ATOM_NET_WORKAREA,
+	ATOM_NET_SUPPORTING_WM_CHECK,
+   ATOM_NET_FRAME_EXTENTS,
+	ATOM_NET_WM_DESKTOP,
+
+	ATOM_NET_WM_STATE,
+	ATOM_NET_WM_STATE_STICKY,
+	ATOM_NET_WM_STATE_MAXIMIZED_VERT,
+	ATOM_NET_WM_STATE_MAXIMIZED_HORZ,
+	ATOM_NET_WM_STATE_SHADED,
+	ATOM_NET_WM_STATE_FULLSCREEN,
+
+	ATOM_NET_WM_ALLOWED_ACTIONS,
+	ATOM_NET_WM_ACTION_MOVE,
+	ATOM_NET_WM_ACTION_RESIZE,
+	ATOM_NET_WM_ACTION_MINIMIZE,
+	ATOM_NET_WM_ACTION_SHADE,
+	ATOM_NET_WM_ACTION_STICK,
+	ATOM_NET_WM_ACTION_MAXIMIZE_HORZ,
+	ATOM_NET_WM_ACTION_MAXIMIZE_VERT,
+	ATOM_NET_WM_ACTION_CHANGE_DESKTOP,
+	ATOM_NET_WM_ACTION_CLOSE,
+
+	ATOM_NET_CLOSE_WINDOW,
+	ATOM_NET_MOVERESIZE_WINDOW,
+
+	ATOM_NET_WM_NAME,
+	ATOM_NET_WM_ICON,
+	ATOM_NET_WM_WINDOW_TYPE,
+	ATOM_NET_WM_WINDOW_TYPE_DESKTOP,
+	ATOM_NET_WM_WINDOW_TYPE_DOCK,
+
+	ATOM_NET_CLIENT_LIST,
+	ATOM_NET_CLIENT_LIST_STACKING,
+
+	ATOM_NET_WM_STRUT_PARTIAL,
+	ATOM_NET_WM_STRUT,
+
+	ATOM_NET_SYSTEM_TRAY_OPCODE,
+
+	/* GNOME atoms */
+	ATOM_WIN_LAYER,
+	ATOM_WIN_STATE,
+	ATOM_WIN_WORKSPACE_COUNT,
+	ATOM_WIN_WORKSPACE,
+	ATOM_WIN_SUPPORTING_WM_CHECK,
+	ATOM_WIN_PROTOCOLS,
+
+	/* MWM atoms */
+	ATOM_MOTIF_WM_HINTS,
+
+	/* JWM-specific atoms. */
+	ATOM_JWM_RESTART,
+	ATOM_JWM_EXIT,
+
+	ATOM_COUNT
+} AtomType;
+
+#define FIRST_NET_ATOM ATOM_NET_SUPPORTED
+#define LAST_NET_ATOM  ATOM_NET_SYSTEM_TRAY_OPCODE
+
+#define FIRST_WIN_ATOM ATOM_WIN_LAYER
+#define LAST_WIN_ATOM  ATOM_WIN_PROTOCOLS
+
+#define FIRST_MWM_ATOM ATOM_MOTIF_WM_HINTS
+#define LAST_MWM_ATOM  ATOM_MOTIF_WM_HINTS
+
+#define WIN_STATE_STICKY          (1UL << 0)
+#define WIN_STATE_MINIMIZED       (1UL << 1)
+#define WIN_STATE_MAXIMIZED_VERT  (1UL << 2)
+#define WIN_STATE_MAXIMIZED_HORIZ (1UL << 3)
+#define WIN_STATE_HIDDEN          (1UL << 4)
+#define WIN_STATE_SHADED          (1UL << 5)
+#define WIN_STATE_HIDE_WORKSPACE  (1UL << 6)
+#define WIN_STATE_HIDE_TRANSIENT  (1UL << 7)
+#define WIN_STATE_FIXED_POSITION  (1UL << 8)
+#define WIN_STATE_ARRANGE_IGNORE  (1UL << 9)
+
+#define WIN_HINT_SKIP_FOCUS      (1UL << 0)
+#define WIN_HINT_SKIP_WINLIST    (1UL << 1)
+#define WIN_HINT_SKIP_TASKBAR    (1UL << 2)
+#define WIN_HINT_GROUP_TRANSIENT (1UL << 3)
+#define WIN_HINT_FOCUS_ON_CLICK  (1UL << 4)
+
+typedef enum {
+	LAYER_BOTTOM              = 0,
+	LAYER_NORMAL              = 4,
+	DEFAULT_TRAY_LAYER        = 8,
+	LAYER_TOP                 = 12,
+	LAYER_COUNT               = 13
+} WinLayerType;
+
+typedef struct ClientState {
+	unsigned int status;
+	unsigned int border;
+	unsigned int layer;
+	unsigned int desktop;
+} ClientState;
+
+typedef enum {
+	PROT_NONE       = 0,
+	PROT_DELETE     = 1,
+	PROT_TAKE_FOCUS = 2
+} ClientProtocolType;
+
+extern Atom atoms[ATOM_COUNT];
+
+void InitializeHints();
+void StartupHints();
+void ShutdownHints();
+void DestroyHints();
+
+void ReadCurrentDesktop();
+
+void ReadClientProtocols(struct ClientNode *np);
+
+void ReadWMName(struct ClientNode *np);
+void ReadWMClass(struct ClientNode *np);
+void ReadWMNormalHints(struct ClientNode *np);
+ClientProtocolType ReadWMProtocols(Window w);
+void ReadWMColormaps(struct ClientNode *np);
+
+void ReadWinLayer(struct ClientNode *np);
+
+ClientState ReadWindowState(Window win);
+
+void WriteState(struct ClientNode *np);
+
+int GetCardinalAtom(Window window, AtomType atom, unsigned long *value);
+int GetWindowAtom(Window window, AtomType atom, Window *value);
+
+void SetCardinalAtom(Window window, AtomType atom, unsigned long value);
+void SetWindowAtom(Window window, AtomType atom, unsigned long value);
+
+#endif
+
diff --git a/src/icon.c b/src/icon.c
new file mode 100644
index 0000000..b6f5ca6
--- /dev/null
+++ b/src/icon.c
@@ -0,0 +1,726 @@
+/****************************************************************************
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "icon.h"
+#include "client.h"
+#include "render.h"
+#include "main.h"
+#include "image.h"
+#include "misc.h"
+#include "hint.h"
+#include "color.h"
+
+static int iconSize = 0;
+
+#ifdef USE_ICONS
+
+#include "x.xpm"
+
+#define HASH_SIZE 64
+
+typedef struct IconPathNode {
+	char *path;
+	struct IconPathNode *next;
+} IconPathNode;
+
+static IconNode **iconHash;
+
+static IconPathNode *iconPaths;
+static IconPathNode *iconPathsTail;
+
+static GC iconGC;
+
+static void SetIconSize();
+
+static void DoDestroyIcon(int index, IconNode *icon);
+static void ReadNetWMIcon(ClientNode *np);
+static IconNode *GetDefaultIcon();
+static IconNode *CreateIconFromData(const char *name, char **data);
+static IconNode *CreateIconFromFile(const char *fileName);
+static IconNode *CreateIconFromBinary(const unsigned long *data,
+	unsigned int length);
+static IconNode *LoadNamedIconHelper(const char *name, const char *path);
+
+static IconNode *LoadSuffixedIcon(const char *path, const char *name,
+	const char *suffix);
+
+static ScaledIconNode *GetScaledIcon(IconNode *icon, int width, int height);
+
+static void InsertIcon(IconNode *icon);
+static IconNode *FindIcon(const char *name);
+static int GetHash(const char *str);
+
+/****************************************************************************
+ * Must be initialized before parsing the configuration.
+ ****************************************************************************/
+void InitializeIcons() {
+
+	int x;
+
+	iconPaths = NULL;
+	iconPathsTail = NULL;
+
+	iconHash = Allocate(sizeof(IconNode*) * HASH_SIZE);
+	for(x = 0; x < HASH_SIZE; x++) {
+		iconHash[x] = NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupIcons() {
+
+	XGCValues gcValues;
+	unsigned long gcMask;
+
+	gcMask = GCGraphicsExposures;
+	gcValues.graphics_exposures = False;
+	iconGC = JXCreateGC(display, rootWindow, gcMask, &gcValues);
+
+	QueryRenderExtension();
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownIcons() {
+
+	int x;
+
+	for(x = 0; x < HASH_SIZE; x++) {
+		while(iconHash[x]) {
+			DoDestroyIcon(x, iconHash[x]);
+		}
+	}
+
+	JXFreeGC(display, iconGC);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyIcons() {
+
+	IconPathNode *pn;
+
+	while(iconPaths) {
+		pn = iconPaths->next;
+		Release(iconPaths->path);
+		Release(iconPaths);
+		iconPaths = pn;
+	}
+	iconPathsTail = NULL;
+
+	if(iconHash) {
+		Release(iconHash);
+		iconHash = NULL;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetIconSize() {
+
+	XIconSize size;
+
+	if(!iconSize) {
+
+		/* FIXME: compute values based on the sizes we can actually use. */
+		iconSize = 32;
+
+		size.min_width = iconSize;
+		size.min_height = iconSize;
+		size.max_width = iconSize;
+		size.max_height = iconSize;
+		size.width_inc = iconSize;
+		size.height_inc = iconSize;
+
+		JXSetIconSizes(display, rootWindow, &size, 1);
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddIconPath(char *path) {
+
+	IconPathNode *ip;
+	int length;
+	int addSep;
+
+	if(!path) {
+		return;
+	}
+
+	Trim(path);
+
+	length = strlen(path);
+	if(path[length - 1] != '/') {
+		addSep = 1;
+	} else {
+		addSep = 0;
+	}
+
+	ip = Allocate(sizeof(IconPathNode));
+	ip->path = Allocate(length + addSep + 1);
+	strcpy(ip->path, path);
+	if(addSep) {
+		ip->path[length] = '/';
+		ip->path[length + 1] = 0;
+	}
+	ExpandPath(&ip->path);
+	ip->next = NULL;
+
+	if(iconPathsTail) {
+		iconPathsTail->next = ip;
+	} else {
+		iconPaths = ip;
+	}
+	iconPathsTail = ip;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void PutIcon(IconNode *icon, Drawable d, int x, int y,
+	int width, int height) {
+
+	ScaledIconNode *node;
+
+	Assert(icon);
+
+	node = GetScaledIcon(icon, width, height);
+
+	if(node) {
+
+		if(PutScaledRenderIcon(icon, node, d, x, y)) {
+			return;
+		}
+
+		if(node->image != None) {
+
+			if(node->mask != None) {
+				JXSetClipOrigin(display, iconGC, x, y);
+				JXSetClipMask(display, iconGC, node->mask);
+			}
+
+			JXCopyArea(display, node->image, d, iconGC, 0, 0,
+				node->width, node->height, x, y);
+
+			if(node->mask != None) {
+				JXSetClipMask(display, iconGC, None);
+				JXSetClipOrigin(display, iconGC, 0, 0);
+			}
+
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void LoadIcon(ClientNode *np) {
+
+	IconPathNode *ip;
+
+	Assert(np);
+
+	SetIconSize();
+
+	DestroyIcon(np->icon);
+	np->icon = NULL;
+
+	/* Attempt to read _NET_WM_ICON for an icon */
+	ReadNetWMIcon(np);
+	if(np->icon) {
+		return;
+	}
+
+	/* Attempt to find an icon for this program in the icon directory */
+	if(np->instanceName) {
+		for(ip = iconPaths; ip; ip = ip->next) {
+
+#ifdef USE_PNG
+			np->icon = LoadSuffixedIcon(ip->path, np->instanceName, ".png");
+			if(np->icon) {
+				return;
+			}
+#endif
+
+#ifdef USE_XPM
+			np->icon = LoadSuffixedIcon(ip->path, np->instanceName, ".xpm");
+			if(np->icon) {
+				return;
+			}
+#endif
+
+		}
+	}
+
+	/* Load the default icon */
+	np->icon = GetDefaultIcon();
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *LoadSuffixedIcon(const char *path, const char *name,
+	const char *suffix) {
+
+	IconNode *result;
+	ImageNode *image;
+	char *iconName;
+
+	Assert(path);
+	Assert(name);
+	Assert(suffix);
+
+	iconName = Allocate(strlen(name)
+		+ strlen(path) + strlen(suffix) + 1);
+	strcpy(iconName, path);
+	strcat(iconName, name);
+	strcat(iconName, suffix);
+
+	result = FindIcon(iconName);
+	if(result) {
+		Release(iconName);
+		return result;
+	}
+
+	image = LoadImage(iconName);
+	if(image) {
+		result = CreateIcon();
+		result->name = iconName;
+		result->image = image;
+		InsertIcon(result);
+		return result;
+	} else {
+		Release(iconName);
+		return NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *LoadNamedIcon(const char *name) {
+
+	IconPathNode *ip;
+	IconNode *icon;
+
+	Assert(name);
+
+	SetIconSize();
+
+	if(name[0] == '/') {
+		return CreateIconFromFile(name);
+	} else {
+		for(ip = iconPaths; ip; ip = ip->next) {
+			icon = LoadNamedIconHelper(name, ip->path);
+			if(icon) {
+				return icon;
+			}
+		}
+		return NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *LoadNamedIconHelper(const char *name, const char *path) {
+
+	IconNode *result;
+	char *temp;
+
+	temp = AllocateStack(strlen(name) + strlen(path) + 1);
+	strcpy(temp, path);
+	strcat(temp, name);
+	result = CreateIconFromFile(temp);
+	ReleaseStack(temp);
+
+	return result;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadNetWMIcon(ClientNode *np) {
+
+	unsigned long count;
+	int status;
+	unsigned long extra;
+	Atom realType;
+	int realFormat;
+	unsigned char *data;
+
+	status = JXGetWindowProperty(display, np->window, atoms[ATOM_NET_WM_ICON],
+		0, 256 * 256 * 4, False, XA_CARDINAL, &realType, &realFormat, &count,
+		&extra, &data);
+
+	if(status == Success && data) {
+		np->icon = CreateIconFromBinary((unsigned long*)data, count);
+		JXFree(data);
+	}
+
+}
+
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *GetDefaultIcon() {
+	return CreateIconFromData("default", x_xpm);
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *CreateIconFromData(const char *name, char **data) {
+
+	ImageNode *image;
+	IconNode *result;
+
+	Assert(name);
+	Assert(data);
+
+	/* Check if this icon has already been loaded */
+	result = FindIcon(name);
+	if(result) {
+		return result;
+	}
+
+	image = LoadImageFromData(data);
+	if(image) {
+		result = CreateIcon();
+		result->name = CopyString(name);
+		result->image = image;
+		InsertIcon(result);
+		return result;
+	} else {
+		return NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *CreateIconFromFile(const char *fileName) {
+
+	ImageNode *image;
+	IconNode *result;
+
+	if(!fileName) {
+		return NULL;
+	}
+
+	/* Check if this icon has already been loaded */
+	result = FindIcon(fileName);
+	if(result) {
+		return result;
+	}
+
+	image = LoadImage(fileName);
+	if(image) {
+		result = CreateIcon();
+		result->name = CopyString(fileName);
+		result->image = image;
+		InsertIcon(result);
+		return result;
+	} else {
+		return NULL;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+ScaledIconNode *GetScaledIcon(IconNode *icon, int rwidth, int rheight) {
+
+	XColor color;
+	ScaledIconNode *np;
+	GC maskGC;
+	int x, y;
+	int index;
+	int alpha;
+	double scalex, scaley;
+	double srcx, srcy;
+	double ratio;
+	int nwidth, nheight;
+
+	Assert(icon);
+	Assert(icon->image);
+
+	if(rwidth == 0) {
+		rwidth = icon->image->width;
+	}
+	if(rheight == 0) {
+		rheight = icon->image->height;
+	}
+
+	ratio = (double)icon->image->width / icon->image->height;
+	nwidth = Min(rwidth, rheight * ratio);
+	nheight = Min(rheight, nwidth / ratio);
+	nwidth = nheight * ratio;
+	if(nwidth < 1) {
+		nwidth = 1;
+	}
+	if(nheight < 1) {
+		nheight = 1;
+	}
+
+	/* Check if this size already exists. */
+	for(np = icon->nodes; np; np = np->next) {
+		if(np->width == nwidth && np->height == nheight) {
+			return np;
+		}
+	}
+
+	/* See if we can use XRender to create the icon. */
+	np = CreateScaledRenderIcon(icon, nwidth, nheight);
+	if(np) {
+		return np;
+	}
+
+	/* Create a new ScaledIconNode the old-fashioned way. */
+	np = Allocate(sizeof(ScaledIconNode));
+	np->width = nwidth;
+	np->height = nheight;
+	np->next = icon->nodes;
+#ifdef USE_XRENDER
+	np->imagePicture = None;
+	np->maskPicture = None;
+#endif
+	icon->nodes = np;
+
+	np->mask = JXCreatePixmap(display, rootWindow, nwidth, nheight, 1);
+	maskGC = JXCreateGC(display, np->mask, 0, NULL);
+	np->image = JXCreatePixmap(display, rootWindow, nwidth, nheight, rootDepth);
+
+	scalex = (double)icon->image->width / nwidth;
+	scaley = (double)icon->image->height / nheight;
+
+	srcy = 0.0;
+	for(y = 0; y < nheight; y++) {
+		srcx = 0.0;
+		for(x = 0; x < nwidth; x++) {
+
+			index = (int)srcy * icon->image->width + (int)srcx;
+
+			alpha = (icon->image->data[index] >> 24) & 0xFFUL;
+			if(alpha >= 128) {
+
+				color.red = ((icon->image->data[index] >> 16) & 0xFFUL) * 257;
+				color.green = ((icon->image->data[index] >> 8) & 0xFFUL) * 257;
+				color.blue = (icon->image->data[index] & 0xFFUL) * 257;
+				GetColor(&color);
+
+				JXSetForeground(display, rootGC, color.pixel);
+				JXDrawPoint(display, np->image, rootGC, x, y);
+
+				JXSetForeground(display, maskGC, 1);
+
+			} else {
+				JXSetForeground(display, maskGC, 0);
+			}
+			JXDrawPoint(display, np->mask, maskGC, x, y);
+
+			srcx += scalex;
+
+		}
+
+		srcy += scaley;
+	}
+
+	JXFreeGC(display, maskGC);
+
+	return np;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *CreateIconFromBinary(const unsigned long *input,
+	unsigned int length) {
+
+	unsigned long height, width;
+	IconNode *result;
+	unsigned long *data;
+	unsigned int x;
+
+	if(!input) {
+		return NULL;
+	}
+
+	width = input[0];
+	height = input[1];
+
+	if(width * height + 2 > length) {
+		Debug("invalid image size: %d x %d + 2 > %d", width, height, length);
+		return NULL;
+	} else if(width == 0 || height == 0) {
+		Debug("invalid image size: %d x %d", width, height);
+		return NULL;
+	}
+
+	result = CreateIcon();
+
+	result->image = Allocate(sizeof(ImageNode));
+	result->image->width = width;
+	result->image->height = height;
+
+	result->image->data = Allocate(width * height * sizeof(unsigned long));
+	data = (unsigned long*)result->image->data;
+
+	/* Note: the data types here might be of different sizes. */
+	for(x = 0; x < width * height; x++) {
+		data[x] = input[x + 2];
+	}
+
+	/* Don't insert this icon since it is transient. */
+
+	return result;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *CreateIcon() {
+
+	IconNode *icon;
+
+	icon = Allocate(sizeof(IconNode));
+	icon->name = NULL;
+	icon->image = NULL;
+	icon->nodes = NULL;
+	icon->next = NULL;
+	icon->prev = NULL;
+
+	return icon;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DoDestroyIcon(int index, IconNode *icon) {
+
+	ScaledIconNode *np;
+
+	if(icon) {
+		while(icon->nodes) {
+			np = icon->nodes->next;
+
+#ifdef USE_XRENDER
+			if(icon->nodes->imagePicture != None) {
+				JXRenderFreePicture(display, icon->nodes->imagePicture);
+			}
+			if(icon->nodes->maskPicture != None) {
+				JXRenderFreePicture(display, icon->nodes->maskPicture);
+			}
+#endif
+
+			if(icon->nodes->image != None) {
+				JXFreePixmap(display, icon->nodes->image);
+			}
+			if(icon->nodes->mask != None) {
+				JXFreePixmap(display, icon->nodes->mask);
+			}
+
+			Release(icon->nodes);
+			icon->nodes = np;
+		}
+
+		if(icon->name) {
+			Release(icon->name);
+		}
+		DestroyImage(icon->image);
+
+		if(icon->prev) {
+			icon->prev->next = icon->next;
+		} else {
+			iconHash[index] = icon->next;
+		}
+		if(icon->next) {
+			icon->next->prev = icon->prev;
+		}
+		Release(icon);
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyIcon(IconNode *icon) {
+
+	int index;
+
+	if(icon && !icon->name) {
+		index = GetHash(icon->name);
+		DoDestroyIcon(index, icon);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void InsertIcon(IconNode *icon) {
+
+	int index;
+
+	Assert(icon);
+	Assert(icon->name);
+
+	index = GetHash(icon->name);
+
+	icon->prev = NULL;
+	if(iconHash[index]) {
+		iconHash[index]->prev = icon;
+	}
+	icon->next = iconHash[index];
+	iconHash[index] = icon;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+IconNode *FindIcon(const char *name) {
+
+	IconNode *icon;
+	int index;
+
+	index = GetHash(name);
+
+	icon = iconHash[index];
+	while(icon) {
+		if(!strcmp(icon->name, name)) {
+			return icon;
+		}
+		icon = icon->next;
+	}
+
+	return NULL;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetHash(const char *str) {
+
+	int x;
+	int hash = 0;
+
+	if(!str || !str[0]) {
+		return hash % HASH_SIZE;
+	}
+
+	for(x = 0; str[x]; x++) {
+		hash = (hash + str[x]) % HASH_SIZE;
+	}
+
+	return hash;
+
+}
+
+#endif /* USE_ICONS */
+
diff --git a/src/icon.h b/src/icon.h
new file mode 100644
index 0000000..ad9645a
--- /dev/null
+++ b/src/icon.h
@@ -0,0 +1,110 @@
+/**
+ * @file icon.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header file for icon functions.
+ *
+ */
+
+#ifndef ICON_H
+#define ICON_H
+
+struct ClientNode;
+
+/** Structure to hold a scaled icon. */
+typedef struct ScaledIconNode {
+
+	int width;   /**< The scaled width of the icon. */
+	int height;  /**< The scaled height of the icon. */
+
+	Pixmap image;
+	Pixmap mask;
+#ifdef USE_XRENDER
+	Picture imagePicture;
+	Picture maskPicture;
+#endif
+
+	struct ScaledIconNode *next;
+
+} ScaledIconNode;
+
+/** Structure to hold an icon. */
+typedef struct IconNode {
+
+	char *name;                    /**< The name of the icon. */
+	struct ImageNode *image;       /**< The image data. */
+	struct ScaledIconNode *nodes;  /**< Scaled versions of the icon. */
+	
+	struct IconNode *next;         /**< The next icon in the list. */
+	struct IconNode *prev;         /**< The previous icon in the list. */
+
+} IconNode;
+
+#ifdef USE_ICONS
+
+/*@{*/
+void InitializeIcons();
+void StartupIcons();
+void ShutdownIcons();
+void DestroyIcons();
+/*@}*/
+
+/** Add an icon path.
+ * This adds a path to the list of icon search paths.
+ * @param path The icon path to add.
+ */
+void AddIconPath(char *path);
+
+/** Render an icon.
+ * This will scale an icon if necessary to fit the requested size. The
+ * aspect ratio of the icon is preserved.
+ * @param icon The icon to render.
+ * @param d The drawable on which to place the icon.
+ * @param x The x offset on the drawable to render the icon.
+ * @param y The y offset on the drawable to render the icon.
+ * @param width The width of the icon to display.
+ * @param height The height of the icon to display.
+ */
+void PutIcon(IconNode *icon, Drawable d, int x, int y,
+	int width, int height);
+
+/** Load an icon for a client.
+ * @param np The client.
+ */
+void LoadIcon(struct ClientNode *np);
+
+/** Load an icon.
+ * @param name The name of the icon to load.
+ * @return A pointer to the icon (NULL if not found).
+ */
+IconNode *LoadNamedIcon(const char *name);
+
+/** Destroy an icon.
+ * @param icon The icon to destroy.
+ */
+void DestroyIcon(IconNode *icon);
+
+/** Create and initialize a new icon structure.
+ * @return The new icon structure.
+ */
+IconNode *CreateIcon();
+
+#else
+
+#define ICON_DUMMY_FUNCTION 0
+
+#define InitializeIcons()               ICON_DUMMY_FUNCTION
+#define StartupIcons()                  ICON_DUMMY_FUNCTION
+#define ShutdownIcons()                 ICON_DUMMY_FUNCTION
+#define DestroyIcons()                  ICON_DUMMY_FUNCTION
+#define AddIconPath( a )                ICON_DUMMY_FUNCTION
+#define PutIcon( a, b, c, d, e, f )     ICON_DUMMY_FUNCTION
+#define LoadIcon( a )                   ICON_DUMMY_FUNCTION
+#define LoadNamedIcon( a )              ICON_DUMMY_FUNCTION
+#define DestroyIcon( a )                ICON_DUMMY_FUNCTION
+
+#endif /* USE_ICONS */
+
+#endif /* ICON_H */
+
diff --git a/src/image.c b/src/image.c
new file mode 100644
index 0000000..af52ae7
--- /dev/null
+++ b/src/image.c
@@ -0,0 +1,362 @@
+/****************************************************************************
+ * Functions to load images.
+ * Copyright (C) 2005 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "image.h"
+#include "main.h"
+#include "error.h"
+#include "color.h"
+
+static ImageNode *LoadPNGImage(const char *fileName);
+static ImageNode *LoadXPMImage(const char *fileName);
+static ImageNode *CreateImageFromXImages(XImage *image, XImage *shape);
+
+#ifdef USE_XPM
+static int AllocateColor(Display *d, Colormap cmap, char *name,
+	XColor *c, void *closure);
+static int FreeColors(Display *d, Colormap cmap, Pixel *pixels, int n,
+	void *closure);
+#endif
+
+/****************************************************************************
+ ****************************************************************************/
+ImageNode *LoadImage(const char *fileName) {
+
+	ImageNode *result;
+
+	if(!fileName) {
+		return NULL;
+	}
+
+	/* Attempt to load the file as a PNG image. */
+	result = LoadPNGImage(fileName);
+	if(result) {
+		return result;
+	}
+
+	/* Attempt to load the file as an XPM image. */
+	result = LoadXPMImage(fileName);
+	if(result) {
+		return result;
+	}
+
+	return NULL;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+ImageNode *LoadImageFromData(char **data) {
+
+	ImageNode *result = NULL;
+
+#ifdef USE_XPM
+
+	XpmAttributes attr;
+	XImage *image;
+	XImage *shape;
+	int rc;
+
+	Assert(data);
+
+	attr.valuemask = XpmAllocColor | XpmFreeColors | XpmColorClosure;
+	attr.alloc_color = AllocateColor;
+	attr.free_colors = FreeColors;
+	attr.color_closure = NULL;
+	rc = XpmCreateImageFromData(display, data, &image, &shape, &attr);
+	if(rc == XpmSuccess) {
+		result = CreateImageFromXImages(image, shape);
+		JXDestroyImage(image);
+		if(shape) {
+			JXDestroyImage(shape);
+		}
+	}
+
+#endif
+
+	return result;
+
+}
+
+/****************************************************************************
+ * Load a PNG image from the given file name. Returns NULL on error.
+ * Since libpng uses longjmp, this function is not reentrant to simplify
+ * the issues surrounding longjmp and local variables.
+ ****************************************************************************/
+ImageNode *LoadPNGImage(const char *fileName) {
+
+#ifdef USE_PNG
+
+	static ImageNode *result;
+	static FILE *fd;
+	static unsigned char **rows;
+	static png_structp pngData;
+	static png_infop pngInfo;
+	static png_infop pngEndInfo;
+	static unsigned char *data;
+
+	unsigned char header[8];
+	unsigned long rowBytes;
+	int bitDepth, colorType;
+	unsigned int x, y;
+	unsigned long temp;
+
+	Assert(fileName);
+
+	result = NULL;
+	fd = NULL;
+	rows = NULL;
+	pngData = NULL;
+	pngInfo = NULL;
+	pngEndInfo = NULL;
+	data = NULL;
+
+	fd = fopen(fileName, "rb");
+	if(!fd) {
+		return NULL;
+	}
+
+	x = fread(header, 1, sizeof(header), fd);
+	if(x != sizeof(header) || png_sig_cmp(header, 0, sizeof(header))) {
+		fclose(fd);
+		return NULL;
+	}
+
+	pngData = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	if(!pngData) {
+		fclose(fd);
+		Warning("could not create read struct for PNG image: %s", fileName);
+		return NULL;
+	}
+
+	if(setjmp(png_jmpbuf(pngData))) {
+		png_destroy_read_struct(&pngData, &pngInfo, &pngEndInfo);
+		if(fd) {
+			fclose(fd);
+		}
+		if(rows) {
+			Release(rows);
+		}
+		if(result) {
+			if(result->data) {
+				Release(result->data);
+			}
+			Release(result);
+		}
+		Warning("error reading PNG image: %s", fileName);
+	}
+
+	pngInfo = png_create_info_struct(pngData);
+	if(!pngInfo) {
+		png_destroy_read_struct(&pngData, NULL, NULL);
+		fclose(fd);
+		Warning("could not create info struct for PNG image: %s", fileName);
+		return NULL;
+	}
+
+	pngEndInfo = png_create_info_struct(pngData);
+	if(!pngEndInfo) {
+		png_destroy_read_struct(&pngData, &pngInfo, NULL);
+		fclose(fd);
+		Warning("could not create end info struct for PNG image: %s", fileName);
+		return NULL;
+	}
+
+	png_init_io(pngData, fd);
+	png_set_sig_bytes(pngData, sizeof(header));
+
+	png_read_info(pngData, pngInfo);
+
+	result = Allocate(sizeof(ImageNode));
+
+	png_get_IHDR(pngData, pngInfo, &result->width, &result->height,
+		&bitDepth, &colorType, NULL, NULL, NULL);
+
+	png_set_expand(pngData);
+
+	if(bitDepth == 16) {
+		png_set_strip_16(pngData);
+	} else if(bitDepth < 8) {
+		png_set_packing(pngData);
+	}
+
+	png_set_swap_alpha(pngData);
+	png_set_filler(pngData, 0xFF, PNG_FILLER_BEFORE);
+
+	if(colorType == PNG_COLOR_TYPE_GRAY
+		|| colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
+		png_set_gray_to_rgb(pngData);
+	}
+
+	png_read_update_info(pngData, pngInfo);
+
+	rowBytes = png_get_rowbytes(pngData, pngInfo);
+	data = Allocate(rowBytes * result->height);
+
+	rows = AllocateStack(result->height * sizeof(result->data));
+
+	y = 0;
+	for(x = 0; x < result->height; x++) {
+		rows[x] = &data[y];
+		y += result->width * 4;
+	}
+
+	png_read_image(pngData, rows);
+
+	png_read_end(pngData, pngInfo);
+	png_destroy_read_struct(&pngData, &pngInfo, &pngEndInfo);
+
+	fclose(fd);
+
+	/* Convert the row data to ARGB format. */
+	/* Source is stored ARGB bytes. */
+	/* Destination is stored in unsigned longs with A most significant. */
+	result->data = Allocate(sizeof(unsigned long)
+		* result->width * result->height);
+	for(y = 0; y < result->height; y++) {
+		for(x = 0; x < result->width; x++) {
+			temp  = (unsigned long)rows[y][4 * x + 0] << 24;
+			temp |= (unsigned long)rows[y][4 * x + 1] << 16;
+			temp |= (unsigned long)rows[y][4 * x + 2] << 8;
+			temp |= (unsigned long)rows[y][4 * x + 3] << 0;
+			result->data[y * result->width + x] = temp;
+		}
+	}
+
+	ReleaseStack(rows);
+	Release(data);
+
+	return result;
+
+#else
+
+	return NULL;
+
+#endif
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+ImageNode *LoadXPMImage(const char *fileName) {
+
+	ImageNode *result = NULL;
+
+#ifdef USE_XPM
+
+	XpmAttributes attr;
+	XImage *image;
+	XImage *shape;
+	int rc;
+
+	Assert(fileName);
+
+	attr.valuemask = XpmAllocColor | XpmFreeColors | XpmColorClosure;
+	attr.alloc_color = AllocateColor;
+	attr.free_colors = FreeColors;
+	attr.color_closure = NULL;
+	rc = XpmReadFileToImage(display, (char*)fileName, &image, &shape, &attr);
+	if(rc == XpmSuccess) {
+		result = CreateImageFromXImages(image, shape);
+
+		JXDestroyImage(image);
+		if(shape) {
+			JXDestroyImage(shape);
+		}
+	}
+
+#endif
+
+	return result;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+ImageNode *CreateImageFromXImages(XImage *image, XImage *shape) {
+
+	ImageNode *result;
+	XColor color;
+	unsigned long red, green, blue, alpha;
+	int index;
+	int x, y;
+
+	result = Allocate(sizeof(ImageNode));
+	result->data = Allocate(sizeof(unsigned long)
+		* image->width * image->height);
+	result->width = image->width;
+	result->height = image->height;
+
+	index = 0;
+	for(y = 0; y < image->height; y++) {
+		for(x = 0; x < image->width; x++) {
+
+			color.pixel = XGetPixel(image, x, y);
+			GetColorFromIndex(&color);
+
+			red = color.red >> 8;
+			green = color.green >> 8;
+			blue = color.blue >> 8;
+
+			alpha = 0;
+			if(!shape || XGetPixel(shape, x, y)) {
+				alpha = 255;
+			}
+
+			result->data[index] = alpha << 24;
+			result->data[index] |= red << 16;
+			result->data[index] |= green << 8;
+			result->data[index] |= blue;
+			++index;
+
+		}
+	}
+
+	return result;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyImage(ImageNode *image) {
+	if(image) {
+		Release(image->data);
+		Release(image);
+	}
+}
+
+/****************************************************************************
+ * Function to allocate a color for libxpm.
+ ****************************************************************************/
+#ifdef USE_XPM
+int AllocateColor(Display *d, Colormap cmap, char *name,
+	XColor *c, void *closure)
+{
+
+	if(name) {
+		if(!JXParseColor(d, cmap, name, c)) {
+			return -1;
+		}
+	}
+
+	GetColorIndex(c);
+	return 1;
+
+}
+#endif
+
+/****************************************************************************
+ * Function to free colors allocated by libxpm.
+ * We don't need to do anything here as color.c takes care of this.
+ ****************************************************************************/
+#ifdef USE_XPM
+int FreeColors(Display *d, Colormap cmap, Pixel *pixels, int n,
+	void *closure) {
+
+	return 1;
+
+}
+#endif
+
diff --git a/src/image.h b/src/image.h
new file mode 100644
index 0000000..1291e1b
--- /dev/null
+++ b/src/image.h
@@ -0,0 +1,47 @@
+/**
+ * @file image.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Functions to load images.
+ *
+ */
+
+#ifndef IMAGE_H
+#define IMAGE_H
+
+/** Structure to represent an image. */
+typedef struct ImageNode {
+
+#ifdef USE_PNG
+	png_uint_32 width;       /**< Width of the image. */
+	png_uint_32 height;      /**< Height of the image. */
+#else
+	int width;               /**< Width of the image. */
+	int height;              /**< Height of the image. */
+#endif
+
+	unsigned long *data;     /**< Image data. */
+
+} ImageNode;
+
+/** Load an image from a file.
+ * @param fileName The file containing the image.
+ * @return A new image node (NULL if the image could not be loaded).
+ */
+ImageNode *LoadImage(const char *fileName);
+
+/** Load an image from data.
+ * The data must be in the format from the EWMH spec.
+ * @param data The image data.
+ * @return A new image node (NULL if there were errors.
+ */
+ImageNode *LoadImageFromData(char **data);
+
+/** Destroy an image node.
+ * @param image The image to destroy.
+ */
+void DestroyImage(ImageNode *image);
+
+#endif
+
diff --git a/src/jwm.h b/src/jwm.h
new file mode 100644
index 0000000..131528a
--- /dev/null
+++ b/src/jwm.h
@@ -0,0 +1,128 @@
+/**
+ * @file jwm.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief The main JWM header file.
+ *
+ */
+
+#ifndef JWM_H
+#define JWM_H
+
+#include "../config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+
+#ifdef HAVE_STDARG_H
+#	include <stdarg.h>
+#endif
+#ifdef HAVE_SIGNAL_H
+#	include <signal.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#	include <unistd.h>
+#endif
+#ifdef HAVE_TIME_H
+#	include <time.h>
+#endif
+#ifdef HAVE_SYS_WAIT_H
+#	include <sys/wait.h>
+#endif
+#ifdef HAVE_SYS_TIME_H
+#	include <sys/time.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#	include <sys/select.h>
+#endif
+
+#include <X11/Xlib.h>
+#ifdef HAVE_X11_XUTIL_H
+#	include <X11/Xutil.h>
+#endif
+#ifdef HAVE_X11_XRESOURCE_H
+#	include <X11/Xresource.h>
+#endif
+#ifdef HAVE_X11_CURSORFONT_H
+#	include <X11/cursorfont.h>
+#endif
+#ifdef HAVE_X11_XPROTO_H
+#	include <X11/Xproto.h>
+#endif
+#ifdef HAVE_X11_XATOM_H
+#	include <X11/Xatom.h>
+#endif
+#ifdef HAVE_X11_KEYSYM_H
+#	include <X11/keysym.h>
+#endif
+
+#ifdef USE_XPM
+#	include <X11/xpm.h>
+#endif
+#ifdef USE_PNG
+#	include <png.h>
+#endif
+#ifdef USE_SHAPE
+#	include <X11/extensions/shape.h>
+#endif
+#ifdef USE_XINERAMA
+#	include <X11/extensions/Xinerama.h>
+#endif
+#ifdef USE_XFT
+#	ifdef HAVE_FT2BUILD_H
+#		include <ft2build.h>
+#	endif
+#	include <X11/Xft/Xft.h>
+#endif
+#ifdef USE_XRENDER
+#	include <X11/extensions/Xrender.h>
+#endif
+#ifdef USE_FRIBIDI
+#	include <fribidi/fribidi.h>
+#	include <fribidi/fribidi_char_sets_utf8.h>
+#endif
+
+#define MAX_DESKTOP_COUNT 8
+
+#define MAX_INCLUDE_DEPTH 16
+
+#define MAX_BORDER_WIDTH 32
+#define MIN_BORDER_WIDTH 3
+#define DEFAULT_BORDER_WIDTH 5
+
+#define MAX_TITLE_HEIGHT 64
+#define MIN_TITLE_HEIGHT 2
+#define DEFAULT_TITLE_HEIGHT 21
+
+#define MAX_DOUBLE_CLICK_DELTA 32
+#define MIN_DOUBLE_CLICK_DELTA 0
+#define DEFAULT_DOUBLE_CLICK_DELTA 2
+
+#define MAX_DOUBLE_CLICK_SPEED 2000
+#define MIN_DOUBLE_CLICK_SPEED 1
+#define DEFAULT_DOUBLE_CLICK_SPEED 400
+
+#define MAX_SNAP_DISTANCE 32
+#define MIN_SNAP_DISTANCE 1
+#define DEFAULT_SNAP_DISTANCE 5
+
+#define MAX_TRAY_BORDER 32
+#define MIN_TRAY_BORDER 0
+#define DEFAULT_TRAY_BORDER 1
+
+#define MOVE_DELTA 3
+
+#define SHELL_NAME "/bin/sh"
+
+#define DEFAULT_MENU_TITLE "JWM"
+
+#define DEFAULT_DESKTOP_COUNT 4
+
+#include "debug.h"
+#include "jxlib.h"
+
+#endif
+
diff --git a/src/jxlib.h b/src/jxlib.h
new file mode 100644
index 0000000..e306c2d
--- /dev/null
+++ b/src/jxlib.h
@@ -0,0 +1,420 @@
+/**
+ * @file jxlib.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Macros to wrap X calls for debugging.
+ *
+ */
+
+#ifndef JXLIB_H
+#define JXLIB_H
+
+#define JXAddToSaveSet( a, b ) \
+	( SetCheckpoint(), XAddToSaveSet( a, b ) )
+
+#define JXAllocColor( a, b, c ) \
+	( SetCheckpoint(), XAllocColor( a, b, c ) )
+
+#define JXGetRGBColormaps( a, b, c, d, e ) \
+	( SetCheckpoint(), XGetRGBColormaps( a, b, c, d, e ) )
+
+#define JXQueryColor( a, b, c ) \
+	( SetCheckpoint(), XQueryColor( a, b, c ) )
+
+#define JXAllowEvents( a, b, c ) \
+	( SetCheckpoint(), XAllowEvents( a, b, c ) )
+
+#define JXChangeProperty( a, b, c, d, e, f, g, h ) \
+	( SetCheckpoint(), XChangeProperty( a, b, c, d, e, f, g, h ) )
+
+#define JXChangeWindowAttributes( a, b, c, d ) \
+	( SetCheckpoint(), XChangeWindowAttributes( a, b, c, d ) )
+
+#define JXCheckTypedEvent( a, b, c ) \
+	( SetCheckpoint(), XCheckTypedEvent( a, b, c ) )
+
+#define JXCheckTypedWindowEvent( a, b, c, d ) \
+	( SetCheckpoint(), XCheckTypedWindowEvent( a, b, c, d ) )
+
+#define JXClearWindow( a, b ) \
+	( SetCheckpoint(), XClearWindow( a, b ) )
+
+#define JXCloseDisplay( a ) \
+	( SetCheckpoint(), XCloseDisplay( a ) )
+
+#define JXConfigureWindow( a, b, c, d ) \
+	( SetCheckpoint(), XConfigureWindow( a, b, c, d ) )
+
+#define JXConnectionNumber( a ) \
+	( SetCheckpoint(), XConnectionNumber( a ) )
+
+#define JXCopyArea( a, b, c, d, e, f, g, h, i, j ) \
+	( SetCheckpoint(), XCopyArea( a, b, c, d, e, f, g, h, i, j ) )
+
+#define JXCopyPlane( a, b, c, d, e, f, g, h, i, j, k ) \
+	( SetCheckpoint(), XCopyPlane( a, b, c, d, e, f, g, h, i, j, k ) )
+
+#define JXCreateFontCursor( a, b ) \
+	( SetCheckpoint(), XCreateFontCursor( a, b ) )
+
+#define JXCreateGC( a, b, c, d ) \
+	( SetCheckpoint(), XCreateGC( a, b, c, d ) )
+
+#define JXCreateImage( a, b, c, d, e, f, g, h, i, j ) \
+	( \
+		SetCheckpoint(), \
+		XCreateImage( a, b, c, d, e, f, g, h, i, j ) \
+	)
+
+#define JXCreatePixmap( a, b, c, d, e ) \
+	( SetCheckpoint(), XCreatePixmap( a, b, c, d, e ) )
+
+#define JXCreatePixmapFromBitmapData( a, b, c, d, e, f, g, h ) \
+	( \
+		SetCheckpoint(), \
+		XCreatePixmapFromBitmapData( a, b, c, d, e, f, g, h ) \
+	)
+
+#define JXCreateSimpleWindow( a, b, c, d, e, f, g, h, i ) \
+	( \
+		SetCheckpoint(), \
+		XCreateSimpleWindow( a, b, c, d, e, f, g, h, i ) \
+	)
+
+#define JXCreateWindow( a, b, c, d, e, f, g, h, i, j, k, l ) \
+	( \
+		SetCheckpoint(), \
+		XCreateWindow( a, b, c, d, e, f, g, h, i, j, k, l ) \
+	)
+
+#define JXDefineCursor( a, b, c ) \
+	( SetCheckpoint(), XDefineCursor( a, b, c ) )
+
+#define JXDestroyImage( a ) \
+	( SetCheckpoint(), XDestroyImage( a ) )
+
+#define JXDestroyWindow( a, b ) \
+	( SetCheckpoint(), XDestroyWindow( a, b ) )
+
+#define JXDrawPoint( a, b, c, d, e ) \
+	( SetCheckpoint(), XDrawPoint( a, b, c, d, e ) )
+
+#define JXDrawLine( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XDrawLine( a, b, c, d, e, f, g ) )
+
+#define JXDrawRectangle( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XDrawRectangle( a, b, c, d, e, f, g ) )
+
+#define JXDrawString( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XDrawString( a, b, c, d, e, f, g ) )
+
+#define JXFetchName( a, b, c ) \
+	( SetCheckpoint(), XFetchName( a, b, c ) )
+
+#define JXFillRectangle( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XFillRectangle( a, b, c, d, e, f, g ) )
+
+#define JXFlush( a ) \
+	( SetCheckpoint(), XFlush( a ) )
+
+#define JXFree( a ) \
+	( SetCheckpoint(), XFree( a ) )
+
+#define JXFreeColors( a, b, c, d, e ) \
+	( SetCheckpoint(), XFreeColors( a, b, c, d, e ) )
+
+#define JXFreeCursor( a, b ) \
+	( SetCheckpoint(), XFreeCursor( a, b ) )
+
+#define JXFreeFont( a, b ) \
+	( SetCheckpoint(), XFreeFont( a, b ) )
+
+#define JXFreeGC( a, b ) \
+	( SetCheckpoint(), XFreeGC( a, b ) )
+
+#define JXFreeModifiermap( a ) \
+	( SetCheckpoint(), XFreeModifiermap( a ) )
+
+#define JXFreePixmap( a, b ) \
+	( SetCheckpoint(), XFreePixmap( a, b ) )
+
+#define JXGetAtomName( a, b ) \
+	( SetCheckpoint(), XGetAtomName( a, b ) )
+
+#define JXGetModifierMapping( a ) \
+	( SetCheckpoint(), XGetModifierMapping( a ) )
+
+#define JXGetSubImage( a, b, c, d, e, f, g, h, i, j, k ) \
+	( SetCheckpoint(), XGetSubImage( a, b, c, d, e, f, g, h, i, j, k ) )
+
+#define JXGetTransientForHint( a, b, c ) \
+	( SetCheckpoint(), XGetTransientForHint( a, b, c ) )
+
+#define JXGetClassHint( a, b, c ) \
+	( SetCheckpoint(), XGetClassHint( a, b, c ) )
+
+#define JXGetWindowAttributes( a, b, c ) \
+	( SetCheckpoint(), XGetWindowAttributes( a, b, c ) )
+
+#define JXGetWindowProperty( a, b, c, d, e, f, g, h, i, j, k, l ) \
+	( SetCheckpoint(), \
+	XGetWindowProperty( a, b, c, d, e, f, g, h, i, j, k, l ) )
+
+#define JXGetWMColormapWindows( a, b, c, d ) \
+	( SetCheckpoint(), XGetWMColormapWindows( a, b, c, d ) )
+
+#define JXGetWMNormalHints( a, b, c, d ) \
+	( SetCheckpoint(), XGetWMNormalHints( a, b, c, d ) )
+
+#define JXSetIconSizes( a, b, c, d ) \
+	( SetCheckpoint(), XSetIconSizes( a, b, c, d ) )
+
+#define JXSetWindowBorder( a, b, c ) \
+	( SetCheckpoint(), XSetWindowBorder( a, b, c ) )
+
+#define JXGetWMHints( a, b ) \
+	( SetCheckpoint(), XGetWMHints( a, b ) )
+
+#define JXGrabButton( a, b, c, d, e, f, g, h, i, j ) \
+	( SetCheckpoint(), XGrabButton( a, b, c, d, e, f, g, h, i, j ) )
+
+#define JXKeycodeToKeysym( a, b, c ) \
+	( SetCheckpoint(), XKeycodeToKeysym( a, b, c ) )
+
+#define JXGrabKey( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XGrabKey( a, b, c, d, e, f, g ) )
+
+#define JXUngrabKey( a, b, c, d ) \
+	( SetCheckpoint(), XUngrabKey( a, b, c, d ) )
+
+#define JXGrabKeyboard( a, b, c, d, e, f ) \
+	( SetCheckpoint(), XGrabKeyboard( a, b, c, d, e, f ) )
+
+#define JXGrabPointer( a, b, c, d, e, f, g, h, i ) \
+	( SetCheckpoint(), XGrabPointer( a, b, c, d, e, f, g, h, i ) )
+
+#define JXGrabServer( a ) \
+	( SetCheckpoint(), XGrabServer( a ) )
+
+#define JXInstallColormap( a, b ) \
+	( SetCheckpoint(), XInstallColormap( a, b ) )
+
+#define JXInternAtom( a, b, c ) \
+	( SetCheckpoint(), XInternAtom( a, b, c ) )
+
+#define JXKeysymToKeycode( a, b ) \
+	( SetCheckpoint(), XKeysymToKeycode( a, b ) )
+
+#define JXKillClient( a, b ) \
+	( SetCheckpoint(), XKillClient( a, b ) )
+
+#define JXLoadQueryFont( a, b ) \
+	( SetCheckpoint(), XLoadQueryFont( a, b ) )
+
+#define JXMapRaised( a, b ) \
+	( SetCheckpoint(), XMapRaised( a, b ) )
+
+#define JXMapWindow( a, b ) \
+	( SetCheckpoint(), XMapWindow( a, b ) )
+
+#define JXMoveResizeWindow( a, b, c, d, e, f ) \
+	( SetCheckpoint(), XMoveResizeWindow( a, b, c, d, e, f ) )
+
+#define JXMoveWindow( a, b, c, d ) \
+	( SetCheckpoint(), XMoveWindow( a, b, c, d ) )
+
+#define JXNextEvent( a, b ) \
+	( SetCheckpoint(), XNextEvent( a, b ) )
+
+#define JXMaskEvent( a, b, c ) \
+	( SetCheckpoint(), XMaskEvent( a, b, c ) )
+
+#define JXCheckMaskEvent( a, b, c ) \
+	( SetCheckpoint(), XCheckMaskEvent( a, b, c ) )
+
+#define JXOpenDisplay( a ) \
+	( SetCheckpoint(), XOpenDisplay( a ) )
+
+#define JXParseColor( a, b, c, d ) \
+	( SetCheckpoint(), XParseColor( a, b, c, d ) )
+
+#define JXPending( a ) \
+	( SetCheckpoint(), XPending( a ) )
+
+#define JXPutBackEvent( a, b ) \
+	( SetCheckpoint(), XPutBackEvent( a, b ) )
+
+#define JXGetImage( a, b, c, d, e, f, g, h ) \
+	( SetCheckpoint(), XGetImage( a, b, c, d, e, f, g, h ) )
+
+#define JXPutImage( a, b, c, d, e, f, g, h, i, j ) \
+	( SetCheckpoint(), XPutImage( a, b, c, d, e, f, g, h, i, j ) )
+
+#define JXQueryPointer( a, b, c, d, e, f, g, h, i ) \
+	( SetCheckpoint(), XQueryPointer( a, b, c, d, e, f, g, h, i ) )
+
+#define JXQueryTree( a, b, c, d, e, f ) \
+	( SetCheckpoint(), XQueryTree( a, b, c, d, e, f ) )
+
+#define JXReparentWindow( a, b, c, d, e ) \
+	( SetCheckpoint(), XReparentWindow( a, b, c, d, e ) )
+
+#define JXRemoveFromSaveSet( a, b ) \
+	( SetCheckpoint(), XRemoveFromSaveSet( a, b ) )
+
+#define JXResizeWindow( a, b, c, d ) \
+	( SetCheckpoint(), XResizeWindow( a, b, c, d ) )
+
+#define JXRestackWindows( a, b, c ) \
+	( SetCheckpoint(), XRestackWindows( a, b, c ) )
+
+#define JXSelectInput( a, b, c ) \
+	( SetCheckpoint(), XSelectInput( a, b, c ) )
+
+#define JXSendEvent( a, b, c, d, e ) \
+	( SetCheckpoint(), XSendEvent( a, b, c, d, e ) )
+
+#define JXSetBackground( a, b, c ) \
+	( SetCheckpoint(), XSetBackground( a, b, c ) )
+
+#define JXSetClipMask( a, b, c ) \
+	( SetCheckpoint(), XSetClipMask( a, b, c ) )
+
+#define JXSetClipOrigin( a, b, c, d ) \
+	( SetCheckpoint(), XSetClipOrigin( a, b, c, d) )
+
+#define JXSetClipRectangles( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XSetClipRectangles( a, b, c, d, e, f, g ) )
+
+#define JXSetErrorHandler( a ) \
+	( SetCheckpoint(), XSetErrorHandler( a ) )
+
+#define JXSetFont( a, b, c ) \
+	( SetCheckpoint(), XSetFont( a, b, c ) )
+
+#define JXSetForeground( a, b, c ) \
+	( SetCheckpoint(), XSetForeground( a, b, c ) )
+
+#define JXSetInputFocus( a, b, c, d ) \
+	( SetCheckpoint(), XSetInputFocus( a, b, c, d ) )
+
+#define JXSetWindowBackground( a, b, c ) \
+	( SetCheckpoint(), XSetWindowBackground( a, b, c ) )
+
+#define JXSetWindowBorderWidth( a, b, c ) \
+	( SetCheckpoint(), XSetWindowBorderWidth( a, b, c ) )
+
+#define JXSetWMNormalHints( a, b, c ) \
+	( SetCheckpoint(), XSetWMNormalHints( a, b, c ) )
+
+#define JXShapeCombineRectangles( a, b, c, d, e, f, g, h, i ) \
+	( SetCheckpoint(), XShapeCombineRectangles( a, b, c, d, e, f, g, h, i ) )
+
+#define JXShapeCombineShape( a, b, c, d, e, f, g, h ) \
+	( SetCheckpoint(), XShapeCombineShape( a, b, c, d, e, f, g, h ) )
+
+#define JXShapeQueryExtension( a, b, c ) \
+	( SetCheckpoint(), XShapeQueryExtension( a, b, c ) )
+
+#define JXShapeQueryExtents( a, b, c, d, e, f, g, h, i, j, k, l ) \
+	( SetCheckpoint(), \
+	XShapeQueryExtents( a, b, c, d, e, f, g, h, i, j, k, l ) )
+
+#define JXShapeSelectInput( a, b, c ) \
+	( SetCheckpoint(), XShapeSelectInput( a, b, c ) )
+
+#define JXStoreName( a, b, c ) \
+	( SetCheckpoint(), XStoreName( a, b, c ) )
+
+#define JXStringToKeysym( a ) \
+	( SetCheckpoint(), XStringToKeysym( a ) )
+
+#define JXSync( a, b ) \
+	( SetCheckpoint(), XSync( a, b ) )
+
+#define JXTextWidth( a, b, c ) \
+	( SetCheckpoint(), XTextWidth( a, b, c ) )
+
+#define JXUngrabButton( a, b, c, d ) \
+	( SetCheckpoint(), XUngrabButton( a, b, c, d ) )
+
+#define JXUngrabKeyboard( a, b ) \
+	( SetCheckpoint(), XUngrabKeyboard( a, b ) )
+
+#define JXUngrabPointer( a, b ) \
+	( SetCheckpoint(), XUngrabPointer( a, b ) )
+
+#define JXUngrabServer( a ) \
+	( SetCheckpoint(), XUngrabServer( a ) )
+
+#define JXUnmapWindow( a, b ) \
+	( SetCheckpoint(), XUnmapWindow( a, b ) )
+
+#define JXWarpPointer( a, b, c, d, e, f, g, h, i ) \
+	( SetCheckpoint(), XWarpPointer( a, b, c, d, e, f, g, h, i ) )
+
+#define JXSetSelectionOwner( a, b, c, d ) \
+	( SetCheckpoint(), XSetSelectionOwner( a, b, c, d ) )
+
+#define JXGetSelectionOwner( a, b ) \
+	( SetCheckpoint(), XGetSelectionOwner( a, b ) )
+
+/* XFT */
+
+#define JXftFontOpenName( a, b, c ) \
+	( SetCheckpoint(), XftFontOpenName( a, b, c ) )
+
+#define JXftFontOpenXlfd( a, b, c ) \
+	( SetCheckpoint(), XftFontOpenXlfd( a, b, c ) )
+
+#define JXftDrawCreate( a, b, c, d ) \
+	( SetCheckpoint(), XftDrawCreate( a, b, c, d ) )
+
+#define JXftDrawDestroy( a ) \
+	( SetCheckpoint(), XftDrawDestroy( a ) )
+
+#define JXftTextExtentsUtf8( a, b, c, d, e ) \
+	( SetCheckpoint(), XftTextExtentsUtf8( a, b, c, d, e ) )
+
+#define JXftDrawChange( a, b ) \
+	( SetCheckpoint(), XftDrawChange( a, b ) )
+
+#define JXftDrawSetClipRectangles( a, b, c, d, e ) \
+	( SetCheckpoint(), XftDrawSetClipRectangles( a, b, c, d, e ) )
+
+#define JXftDrawStringUtf8( a, b, c, d, e, f, g ) \
+	( SetCheckpoint(), XftDrawStringUtf8( a, b, c, d, e, f, g ) )
+
+#define JXftColorFree( a, b, c, d ) \
+	( SetCheckpoint(), XftColorFree( a, b, c, d ) )
+
+#define JXftColorAllocValue( a, b, c, d, e ) \
+	( SetCheckpoint(), XftColorAllocValue( a, b, c, d, e ) )
+
+#define JXftFontClose( a, b ) \
+	( SetCheckpoint(), XftFontClose( a, b ) )
+
+/* Xrender */
+
+#define JXRenderQueryExtension( a, b, c ) \
+	( SetCheckpoint(), XRenderQueryExtension( a, b, c ) )
+
+#define JXRenderFindVisualFormat( a, b ) \
+	( SetCheckpoint(), XRenderFindVisualFormat( a, b ) )
+
+#define JXRenderFindFormat( a, b, c, d ) \
+	( SetCheckpoint(), XRenderFindFormat( a, b, c, d ) )
+
+#define JXRenderCreatePicture( a, b, c, d, e ) \
+	( SetCheckpoint(), XRenderCreatePicture( a, b, c, d, e ) )
+
+#define JXRenderFreePicture( a, b ) \
+	( SetCheckpoint(), XRenderFreePicture( a, b ) )
+
+#define JXRenderComposite( a, b, c, d, e, f, g, h, i, j, k, l, m ) \
+	( SetCheckpoint(), \
+	  XRenderComposite( a, b, c, d, e, f, g, h, i, j, k, l, m) )
+
+#endif /* JXLIB_H */
+
diff --git a/src/key.c b/src/key.c
new file mode 100644
index 0000000..b6e9ee6
--- /dev/null
+++ b/src/key.c
@@ -0,0 +1,452 @@
+/***************************************************************************
+ * Key input functions.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "key.h"
+#include "main.h"
+#include "client.h"
+#include "root.h"
+#include "error.h"
+#include "tray.h"
+#include "misc.h"
+
+typedef enum {
+	MASK_NONE  = 0,
+	MASK_ALT   = 1,
+	MASK_CTRL  = 2,
+	MASK_SHIFT = 4,
+	MASK_HYPER = 8,
+	MASK_META  = 16,
+	MASK_SUPER = 32
+} MaskType;
+
+typedef struct KeyNode {
+
+	/* These are filled in when the configuration file is parsed */
+	int key;
+	unsigned int mask;
+	KeySym symbol;
+	char *command;
+	struct KeyNode *next;
+
+	/* This is filled in by StartupKeys if it isn't already set. */
+	KeyCode code;
+
+	/* This is filled in by StartupKeys. */
+	unsigned int state;
+
+} KeyNode;
+
+typedef struct LockNode {
+	KeySym symbol;
+	unsigned int mask;
+} LockNode;
+
+static XModifierKeymap *modmap;
+
+static LockNode mods[] = {
+	{ XK_Caps_Lock,   0 },
+	{ XK_Num_Lock,    0 }
+};
+
+static KeyNode *bindings;
+static unsigned int modifierMask;
+
+static unsigned int GetModifierMask(KeySym key);
+static unsigned int ParseModifierString(const char *str);
+static KeySym ParseKeyString(const char *str);
+static int ShouldGrab(KeyType key);
+static void GrabKey(KeyNode *np);
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeKeys() {
+
+	bindings = NULL;
+	modifierMask = 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void StartupKeys() {
+
+	KeyNode *np;
+	int x;
+
+	modmap = JXGetModifierMapping(display);
+
+	for(x = 0; x < sizeof(mods) / sizeof(mods[0]); x++) {
+		mods[x].mask = GetModifierMask(mods[x].symbol);
+		modifierMask |= mods[x].mask;
+	}
+
+	for(np = bindings; np; np = np->next) {
+
+		np->state = 0;
+		if(np->mask & MASK_ALT) {
+			np->state |= GetModifierMask(XK_Alt_L);
+		}
+		if(np->mask & MASK_CTRL) {
+			np->state |= GetModifierMask(XK_Control_L);
+		}
+		if(np->mask & MASK_SHIFT) {
+			np->state |= GetModifierMask(XK_Shift_L);
+		}
+		if(np->mask & MASK_HYPER) {
+			np->state |= GetModifierMask(XK_Hyper_L);
+		}
+		if(np->mask & MASK_META) {
+			np->state |= GetModifierMask(XK_Meta_L);
+		}
+		if(np->mask & MASK_SUPER) {
+			np->state |= GetModifierMask(XK_Super_L);
+		}
+
+		if(!np->code) {
+			np->code = JXKeysymToKeycode(display, np->symbol);
+		}
+
+		if(ShouldGrab(np->key)) {
+			GrabKey(np);
+		}
+
+	}
+
+	JXFreeModifiermap(modmap);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShutdownKeys() {
+
+	ClientNode *np;
+	int layer;
+
+	for(layer = 0; layer < LAYER_COUNT; layer++) {
+		for(np = nodes[layer]; np; np = np->next) {
+			JXUngrabKey(display, AnyKey, AnyModifier, np->window);
+		}
+	}
+
+	JXUngrabKey(display, AnyKey, AnyModifier, rootWindow);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyKeys() {
+
+	KeyNode *np;
+
+	while(bindings) {
+		np = bindings->next;
+		if(bindings->command) {
+			Release(bindings->command);
+		}
+		Release(bindings);
+		bindings = np;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void GrabKey(KeyNode *np) {
+
+	TrayType *tp;
+	int x;
+	int index, maxIndex;
+	unsigned int mask;
+
+	maxIndex = 1 << (sizeof(mods) / sizeof(mods[0]));
+	for(index = 0; index < maxIndex; index++) {
+
+		mask = 0;
+		for(x = 0; x < sizeof(mods) / sizeof(mods[0]); x++) {
+			if(index & (1 << x)) {
+				mask |= mods[x].mask;
+			}
+		}
+
+		mask |= np->state;
+		JXGrabKey(display, np->code, mask,
+			rootWindow, True, GrabModeAsync, GrabModeAsync);
+		for(tp = GetTrays(); tp; tp = tp->next) {
+			JXGrabKey(display, np->code, mask,
+				tp->window, True, GrabModeAsync, GrabModeAsync);
+		}
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+KeyType GetKey(const XKeyEvent *event) {
+
+	KeyNode *np;
+	unsigned int state;
+
+	state = event->state & ~modifierMask;
+	for(np = bindings; np; np = np->next) {
+		if(np->state == state && np->code == event->keycode) {
+			return np->key;
+		}
+	}
+
+	return KEY_NONE;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void RunKeyCommand(const XKeyEvent *event) {
+
+	KeyNode *np;
+
+	for(np = bindings; np; np = np->next) {
+		if(np->state == event->state && np->code == event->keycode) {
+			RunCommand(np->command);
+			return;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShowKeyMenu(const XKeyEvent *event) {
+
+	KeyNode *np;
+	int button;
+
+	for(np = bindings; np; np = np->next) {
+		if(np->state == event->state && np->code == event->keycode) {
+			button = atoi(np->command);
+			if(button >= 0 && button <= 9) {
+				ShowRootMenu(button, 0, 0);
+			}
+			return;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ShouldGrab(KeyType key) {
+	switch(key & 0xFF) {
+	case KEY_NEXT:
+	case KEY_NEXT_STACKED:
+	case KEY_CLOSE:
+	case KEY_MIN:
+	case KEY_MAX:
+	case KEY_SHADE:
+	case KEY_MOVE:
+	case KEY_RESIZE:
+	case KEY_ROOT:
+	case KEY_WIN:
+	case KEY_DESKTOP:
+	case KEY_EXEC:
+	case KEY_RESTART:
+	case KEY_EXIT:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void GrabKeys(ClientNode *np) {
+
+	KeyNode *kp;
+
+	for(kp = bindings; kp; kp = kp->next) {
+		if(ShouldGrab(kp->key)) {
+			JXGrabKey(display, kp->code, kp->state,
+				np->window, True, GrabModeAsync, GrabModeAsync);
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+unsigned int GetModifierMask(KeySym key) {
+
+	KeyCode temp;
+	int x;
+
+	temp = JXKeysymToKeycode(display, key);
+	for(x = 0; x < 8 * modmap->max_keypermod; x++) {
+		if(modmap->modifiermap[x] == temp) {
+			return 1 << (x / modmap->max_keypermod);
+		}
+	}
+
+	Warning("modifier not found for keysym 0x%0x", key);
+
+	return 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+unsigned int ParseModifierString(const char *str) {
+	unsigned int mask;
+	int x;
+
+	if(!str) {
+		return MASK_NONE;
+	}
+
+	mask = MASK_NONE;
+	for(x = 0; str[x]; x++) {
+		switch(str[x]) {
+		case 'A':
+			mask |= MASK_ALT;
+			break;
+		case 'C':
+			mask |= MASK_CTRL;
+			break;
+		case 'S':
+			mask |= MASK_SHIFT;
+			break;
+		case 'H':
+			mask |= MASK_HYPER;
+			break;
+		case 'M':
+			mask |= MASK_META;
+			break;
+		case 'P':
+			mask |= MASK_SUPER;
+			break;
+		default:
+			Warning("invalid modifier: \"%c\"", str[x]);
+			break;
+		}
+	}
+
+	return mask;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+KeySym ParseKeyString(const char *str) {
+
+	KeySym symbol;
+
+	symbol = JXStringToKeysym(str);
+	if(symbol == NoSymbol) {
+		Warning("invalid key symbol: \"%s\"", str);
+	}
+
+	return symbol;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void InsertBinding(KeyType key, const char *modifiers,
+	const char *stroke, const char *code, const char *command) {
+
+	KeyNode *np;
+	unsigned int mask;
+	char *temp;
+	int offset;
+	KeySym sym;
+
+	mask = ParseModifierString(modifiers);
+
+	if(stroke && strlen(stroke) > 0) {
+
+		for(offset = 0; stroke[offset]; offset++) {
+			if(stroke[offset] == '#') {
+
+				temp = CopyString(stroke);
+
+				for(temp[offset] = '1'; temp[offset] <= '9'; temp[offset]++) {
+
+					sym = ParseKeyString(temp);
+					if(sym == NoSymbol) {
+						Release(temp);
+						return;
+					}
+
+					np = Allocate(sizeof(KeyNode));
+					np->next = bindings;
+					bindings = np;
+
+					np->key = key | ((temp[offset] - '1' + 1) << 8);
+					np->mask = mask;
+					np->symbol = sym;
+					np->command = NULL;
+					np->code = 0;
+
+				}
+
+				Release(temp);
+
+				return;
+			}
+		}
+
+		sym = ParseKeyString(stroke);
+		if(sym == NoSymbol) {
+			return;
+		}
+
+		np = Allocate(sizeof(KeyNode));
+		np->next = bindings;
+		bindings = np;
+
+		np->key = key;
+		np->mask = mask;
+		np->symbol = sym;
+		np->command = CopyString(command);
+		np->code = 0;
+
+	} else if(code && strlen(code) > 0) {
+
+		np = Allocate(sizeof(KeyNode));
+		np->next = bindings;
+		bindings = np;
+
+		np->key = key;
+		np->mask = mask;
+		np->symbol = NoSymbol;
+		np->command = CopyString(command);
+		np->code = atoi(code);
+
+	} else {
+
+		Warning("neither key nor keycode specified for Key");
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ValidateKeys() {
+
+	KeyNode *kp;
+	int bindex;
+
+	for(kp = bindings; kp; kp = kp->next) {
+		if((kp->key & 0xFF) == KEY_ROOT && kp->command) {
+			bindex = atoi(kp->command);
+			if(!IsRootMenuDefined(bindex)) {
+				Warning("key binding: root menu %d not defined", bindex);
+			}
+		}
+	}
+
+}
+
diff --git a/src/key.h b/src/key.h
new file mode 100644
index 0000000..a18aa46
--- /dev/null
+++ b/src/key.h
@@ -0,0 +1,57 @@
+/**
+ * @file key.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the key binding functions.
+ *
+ */
+
+#ifndef KEY_H
+#define KEY_H
+
+struct ClientNode;
+
+typedef enum {
+	KEY_NONE         = 0,
+	KEY_UP           = 1,
+	KEY_DOWN         = 2,
+	KEY_RIGHT        = 3,
+	KEY_LEFT         = 4,
+	KEY_ESC          = 5,
+	KEY_ENTER        = 6,
+	KEY_NEXT         = 7,
+	KEY_NEXT_STACKED = 8,
+	KEY_CLOSE        = 9,
+	KEY_MIN          = 10,
+	KEY_MAX          = 11,
+	KEY_SHADE        = 12,
+	KEY_MOVE         = 13,
+	KEY_RESIZE       = 14,
+	KEY_ROOT         = 15,
+	KEY_WIN          = 16,
+	KEY_DESKTOP      = 17,
+	KEY_EXEC         = 18,
+	KEY_RESTART      = 19,
+	KEY_EXIT         = 20
+} KeyType;
+
+void InitializeKeys();
+void StartupKeys();
+void ShutdownKeys();
+void DestroyKeys();
+
+KeyType GetKey(const XKeyEvent *event);
+void GrabKeys(struct ClientNode *np);
+
+void InsertBinding(KeyType key, const char *modifiers,
+	const char *stroke, const char *code, const char *command);
+
+void RunKeyCommand(const XKeyEvent *event);
+
+void ShowKeyMenu(const XKeyEvent *event);
+
+void ValidateKeys();
+
+#endif
+
diff --git a/src/lex.c b/src/lex.c
new file mode 100644
index 0000000..0e0f65d
--- /dev/null
+++ b/src/lex.c
@@ -0,0 +1,572 @@
+/*****************************************************************************
+ * XML lexer functions.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ *****************************************************************************/
+
+#include "jwm.h"
+#include "lex.h"
+#include "error.h"
+#include "misc.h"
+
+static const int BLOCK_SIZE = 16;
+
+/* Order is important! The order must match the order in lex.h */
+static const char *TOKEN_MAP[] = {
+	"[invalid]",
+	"ActiveBackground",
+	"ActiveForeground",
+	"Background",
+	"BorderStyle",
+	"Class",
+	"Clock",
+	"ClockStyle",
+	"Close",
+	"Desktops",
+	"Dock",
+	"DoubleClickSpeed",
+	"DoubleClickDelta",
+	"Exit",
+	"FocusModel",
+	"Font",
+	"Foreground",
+	"Group",
+	"Height",
+	"IconPath",
+	"Include",
+	"JWM",
+	"Key",
+	"Kill",
+	"Layer",
+	"Maximize",
+	"Menu",
+	"MenuStyle",
+	"Minimize",
+	"Mouse",
+	"Move",
+	"MoveMode",
+	"Name",
+	"Option",
+	"Outline",
+	"Pager",
+	"PagerStyle",
+	"Popup",
+	"PopupStyle",
+	"Program",
+	"Resize",
+	"ResizeMode",
+	"Restart",
+	"RestartCommand",
+	"RootMenu",
+	"SendTo",
+	"Separator",
+	"Shade",
+	"ShutdownCommand",
+	"SnapMode",
+	"StartupCommand",
+	"Stick",
+	"Swallow",
+	"TaskListStyle",
+	"TaskList",
+	"Theme",
+	"ThemePath",
+	"Tray",
+	"TrayButton",
+	"TrayButtonStyle",
+	"TrayStyle",
+	"Width"
+};
+
+static TokenNode *head, *current;
+
+static TokenNode *CreateNode(TokenNode *parent, const char *file, int line);
+static AttributeNode *CreateAttribute(TokenNode *np); 
+
+static int IsElementEnd(char ch);
+static int IsValueEnd(char ch);
+static int IsAttributeEnd(char ch);
+static int IsSpace(char ch, int *lineNumber);
+static char *ReadElementName(const char *line);
+static char *ReadElementValue(const char *line,
+	const char *file, int *lineNumber);
+static char *ReadAttributeValue(const char *line, const char *file,
+	int *lineNumber);
+static int ParseEntity(const char *entity, char *ch,
+	const char *file, int line);
+static TokenType LookupType(const char *name, TokenNode *np);
+
+/*****************************************************************************
+ *****************************************************************************/
+TokenNode *Tokenize(const char *line, const char *fileName) {
+
+	TokenNode *np;
+	AttributeNode *ap;
+	char *temp;
+	int inElement;
+	int x;
+	int found;
+	int lineNumber;
+
+	head = NULL;
+	current = NULL;
+	inElement = 0;
+	lineNumber = 1;
+
+	x = 0;
+	/* Skip any initial white space */
+	while(IsSpace(line[x], &lineNumber)) ++x;
+
+	/* Skip any XML stuff */
+	if(!strncmp(line + x, "<?", 2)) {
+		while(line[x]) {
+			if(line[x] == '\n') {
+				++lineNumber;
+			}
+			if(!strncmp(line + x, "?>", 2)) {
+				x += 2;
+				break;
+			}
+			++x;
+		}
+	}
+
+	while(line[x]) {
+
+		do {
+
+			while(IsSpace(line[x], &lineNumber)) ++x;
+
+			/* Skip comments */
+			found = 0;
+			if(!strncmp(line + x, "<!--", 4)) {
+				while(line[x]) {
+					if(line[x] == '\n') {
+						++lineNumber;
+					}
+					if(!strncmp(line + x, "-->", 3)) {
+						x += 3;
+						found = 1;
+						break;
+					}
+					++x;
+				}
+			}
+		} while(found);
+
+		switch(line[x]) {
+		case '<':
+			++x;
+			if(line[x] == '/') {
+				++x;
+				temp = ReadElementName(line + x);
+
+				if(current) {
+
+					if(temp) {
+
+						if(current->type != LookupType(temp, NULL)) {
+							Warning("%s[%d]: close tag \"%s\" does not "
+								"match open tag \"%s\"",
+								fileName, lineNumber, temp,
+								GetTokenName(current));
+						}
+
+					} else {
+						Warning("%s[%d]: unexpected and invalid close tag",
+							fileName, lineNumber);
+					}
+
+					current = current->parent;
+				} else {
+					if(temp) {
+						Warning("%s[%d]: close tag \"%s\" without open "
+							"tag", fileName, lineNumber, temp);
+					} else {
+						Warning("%s[%d]: invalid close tag", fileName, lineNumber);
+					}
+				}
+
+				if(temp) {
+					x += strlen(temp);
+					Release(temp);
+				}
+
+			} else {
+				np = current;
+				current = NULL;
+				np = CreateNode(np, fileName, lineNumber);
+				temp = ReadElementName(line + x);
+				if(temp) {
+					x += strlen(temp);
+					LookupType(temp, np);
+					Release(temp);
+				} else {
+					Warning("%s[%d]: invalid open tag", fileName, lineNumber);
+				}
+			}
+			inElement = 1;
+			break;
+		case '/':
+			if(inElement) {
+				++x;
+				if(line[x] == '>' && current) {
+					++x;
+					current = current->parent;
+					inElement = 0;
+				} else {
+					Warning("%s[%d]: invalid tag", fileName, lineNumber);
+				}
+			} else {
+				goto ReadDefault;
+			}
+			break;
+		case '>':
+			++x;
+			inElement = 0;
+			break;
+		default:
+ReadDefault:
+			if(inElement) {
+				ap = CreateAttribute(current);
+				ap->name = ReadElementName(line + x);
+				if(ap->name) {
+					x += strlen(ap->name);
+					if(line[x] == '=') {
+						++x;
+					}
+					if(line[x] == '\"') {
+						++x;
+					}
+					ap->value = ReadAttributeValue(line + x, fileName,
+						&lineNumber);
+					if(ap->value) {
+						x += strlen(ap->value);
+					}
+					if(line[x] == '\"') {
+						++x;
+					}
+				}
+			} else {
+				temp = ReadElementValue(line + x, fileName, &lineNumber);
+				if(temp) {
+					x += strlen(temp);
+					if(current) {
+						if(current->value) {
+							current->value = Reallocate(current->value,
+								strlen(current->value) + strlen(temp) + 1);
+							strcat(current->value, temp);
+							Release(temp);
+						} else {
+							current->value = temp;
+						}
+					} else {
+						if(temp[0]) {
+							Warning("%s[%d]: unexpected text: \"%s\"",
+								fileName, lineNumber, temp);
+						}
+						Release(temp);
+					}
+				}
+			}
+			break;
+		}
+	}
+
+	return head;
+}
+
+/*****************************************************************************
+ * Parse an entity reference.
+ * The entity value is returned in ch and the length of the entity
+ * is returned as the value of the function.
+ *****************************************************************************/
+int ParseEntity(const char *entity, char *ch, const char *file, int line) {
+	char *temp;
+	int x;
+
+	if(!strncmp("&quot;", entity, 6)) {
+		*ch = '\"';
+		return 6;
+	} else if(!strncmp("&lt;", entity, 4)) {
+		*ch = '<';
+		return 4;
+	} else if(!strncmp("&gt;", entity, 4)) {
+		*ch = '>';
+		return 4;
+	} else if(!strncmp("&amp;", entity, 5)) {
+		*ch = '&';
+		return 5;
+	} else if(!strncmp("&apos;", entity, 6)) {
+		*ch = '\'';
+		return 6;
+	} else {
+		for(x = 0; entity[x]; x++) {
+			if(entity[x] == ';') {
+				break;
+			}
+		}
+		temp = AllocateStack(x + 2);
+		strncpy(temp, entity, x + 1);
+		temp[x + 1] = 0;
+		Warning("%s[%d]: invalid entity: \"%.8s\"", file, line, temp);
+		ReleaseStack(temp);
+		*ch = '&';
+		return 1;
+	}
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+int IsElementEnd(char ch) {
+	switch(ch) {
+	case ' ':
+	case '\t':
+	case '\n':
+	case '\r':
+	case '\"':
+	case '>':
+	case '<':
+	case '/':
+	case '=':
+	case 0:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+int IsAttributeEnd(char ch) {
+	switch(ch) {
+	case 0:
+	case '\"':
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+int IsValueEnd(char ch) {
+	switch(ch) {
+	case 0:
+	case '<':
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+int IsSpace(char ch, int *lineNumber) {
+	switch(ch) {
+	case ' ':
+	case '\t':
+	case '\r':
+		return 1;
+	case '\n':
+		++*lineNumber;
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+char *ReadElementName(const char *line) {
+	char *buffer;
+	int len, max;
+	int x;
+
+	len = 0;
+	max = BLOCK_SIZE;
+	buffer = Allocate(max + 1);
+
+	for(x = 0; !IsElementEnd(line[x]); x++) {
+		buffer[len++] = line[x];
+		if(len >= max) {
+			max += BLOCK_SIZE;
+			buffer = Reallocate(buffer, max + 1);
+		}
+	}
+	buffer[len] = 0;
+
+	return buffer;
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+char *ReadElementValue(const char *line, const char *file, int *lineNumber) {
+	char *buffer;
+	char ch;
+	int len, max;
+	int x;
+
+	len = 0;
+	max = BLOCK_SIZE;
+	buffer = Allocate(max + 1);
+
+	for(x = 0; !IsValueEnd(line[x]); x++) {
+		if(line[x] == '&') {
+			x += ParseEntity(line + x, &ch, file, *lineNumber) - 1;
+			if(ch) {
+				buffer[len] = ch;
+			} else {
+				buffer[len] = line[x];
+			}
+		} else {
+			if(line[x] == '\n') {
+				++*lineNumber;
+			}
+			buffer[len] = line[x];
+		}
+		++len;
+		if(len >= max) {
+			max += BLOCK_SIZE;
+			buffer = Reallocate(buffer, max + 1);
+		}
+	}
+	buffer[len] = 0;
+	Trim(buffer);
+
+	return buffer;
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+char *ReadAttributeValue(const char *line, const char *file,
+	int *lineNumber) {
+
+	char *buffer;
+	char ch;
+	int len, max;
+	int x;
+
+	len = 0;
+	max = BLOCK_SIZE;
+	buffer = Allocate(max + 1);
+
+	for(x = 0; !IsAttributeEnd(line[x]); x++) {
+		if(line[x] == '&') {
+			x += ParseEntity(line + x, &ch, file, *lineNumber) - 1;
+			if(ch) {
+				buffer[len] = ch;
+			} else {
+				buffer[len] = line[x];
+			}
+		} else {
+			if(line[x] == '\n') {
+				++*lineNumber;
+			}
+			buffer[len] = line[x];
+		}
+		++len;
+		if(len >= max) {
+			max += BLOCK_SIZE;
+			buffer = Reallocate(buffer, max + 1);
+		}
+	}
+	buffer[len] = 0;
+
+	return buffer;
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+TokenType LookupType(const char *name, TokenNode *np) {
+	unsigned int x;
+
+	Assert(name);
+
+	for(x = 0; x < sizeof(TOKEN_MAP) / sizeof(char*); x++) {
+		if(!strcmp(name, TOKEN_MAP[x])) {
+			if(np) {
+				np->type = x;
+			}
+			return x;
+		}
+	}
+
+	if(np) {
+		np->type = TOK_INVALID;
+		np->invalidName = CopyString(name);
+	}
+
+	return TOK_INVALID;
+
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+const char *GetTokenName(const TokenNode *tp) {
+	if(tp->invalidName) {
+		return tp->invalidName;
+	} else if(tp->type >= sizeof(TOKEN_MAP) / sizeof(const char*)) {
+		return "[invalid]";
+	} else {
+		return TOKEN_MAP[tp->type];
+	}
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+const char *GetTokenTypeName(TokenType type) {
+	return TOKEN_MAP[type];
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+TokenNode *CreateNode(TokenNode *parent, const char *file, int line) {
+	TokenNode *np;
+
+	np = Allocate(sizeof(TokenNode));
+	np->type = TOK_INVALID;
+	np->value = NULL;
+	np->attributes = NULL;
+	np->subnodeHead = NULL;
+	np->subnodeTail = NULL;
+	np->parent = parent;
+	np->next = NULL;
+
+	np->fileName = Allocate(strlen(file) + 1);
+	strcpy(np->fileName, file);
+	np->line = line;
+	np->invalidName = NULL;
+
+	if(!head) {
+		head = np;
+	}
+	if(parent) {
+		if(parent->subnodeHead) {
+			parent->subnodeTail->next = np;
+		} else {
+			parent->subnodeHead = np;
+		}
+		parent->subnodeTail = np;
+	} else if(current) {
+		current->next = np;
+	}
+	current = np;
+
+	return np;
+}
+
+/*****************************************************************************
+ *****************************************************************************/
+AttributeNode *CreateAttribute(TokenNode *np) {
+	AttributeNode *ap;
+
+	ap = Allocate(sizeof(AttributeNode));
+	ap->name = NULL;
+	ap->value = NULL;
+
+	ap->next = np->attributes;
+	np->attributes = ap;
+
+	return ap;
+}
+
+
diff --git a/src/lex.h b/src/lex.h
new file mode 100644
index 0000000..2105d0e
--- /dev/null
+++ b/src/lex.h
@@ -0,0 +1,115 @@
+/**
+ * @file lex.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief XML lexer header file.
+ *
+ */
+
+#ifndef LEX_H
+#define LEX_H
+
+/** Tokens.
+ * Note that any change made to this typedef must be reflected in
+ * TOKEN_MAP in lex.c.
+ */
+typedef enum {
+
+	TOK_INVALID,
+
+	TOK_ACTIVEBACKGROUND,
+	TOK_ACTIVEFOREGROUND,
+	TOK_BACKGROUND,
+	TOK_BORDERSTYLE,
+	TOK_CLASS,
+	TOK_CLOCK,
+	TOK_CLOCKSTYLE,
+	TOK_CLOSE,
+	TOK_DESKTOPS,
+	TOK_DOCK,
+	TOK_DOUBLECLICKSPEED,
+	TOK_DOUBLECLICKDELTA,
+	TOK_EXIT,
+	TOK_FOCUSMODEL,
+	TOK_FONT,
+	TOK_FOREGROUND,
+	TOK_GROUP,
+	TOK_HEIGHT,
+	TOK_ICONPATH,
+	TOK_INCLUDE,
+	TOK_JWM,
+	TOK_KEY,
+	TOK_KILL,
+	TOK_LAYER,
+	TOK_MAXIMIZE,
+	TOK_MENU,
+	TOK_MENUSTYLE,
+	TOK_MINIMIZE,
+	TOK_MOUSE,
+	TOK_MOVE,
+	TOK_MOVEMODE,
+	TOK_NAME,
+	TOK_OPTION,
+	TOK_OUTLINE,
+	TOK_PAGER,
+	TOK_PAGERSTYLE,
+	TOK_POPUP,
+	TOK_POPUPSTYLE,
+	TOK_PROGRAM,
+	TOK_RESIZE,
+	TOK_RESIZEMODE,
+	TOK_RESTART,
+	TOK_RESTARTCOMMAND,
+	TOK_ROOTMENU,
+	TOK_SENDTO,
+	TOK_SEPARATOR,
+	TOK_SHADE,
+	TOK_SHUTDOWNCOMMAND,
+	TOK_SNAPMODE,
+	TOK_STARTUPCOMMAND,
+	TOK_STICK,
+	TOK_SWALLOW,
+	TOK_TASKLISTSTYLE,
+	TOK_TASKLIST,
+	TOK_THEME,
+	TOK_THEMEPATH,
+	TOK_TRAY,
+	TOK_TRAYBUTTON,
+	TOK_TRAYBUTTONSTYLE,
+	TOK_TRAYSTYLE,
+	TOK_WIDTH
+
+} TokenType;
+
+/** Structure to represent an XML attribute. */
+typedef struct AttributeNode {
+
+	char *name;                  /**< The name of the attribute. */
+	char *value;                 /**< The value for the attribute. */
+	struct AttributeNode *next;  /**< The next attribute in the list. */
+
+} AttributeNode;
+
+/** Structure to represent an XML tag. */
+typedef struct TokenNode {
+
+	TokenType type;
+	char *invalidName;
+	char *value;
+	char *fileName;
+	int line;
+	struct AttributeNode *attributes;
+	struct TokenNode *parent;
+	struct TokenNode *subnodeHead, *subnodeTail;
+	struct TokenNode *next;
+
+} TokenNode;
+
+TokenNode *Tokenize(const char *line, const char *fileName);
+
+const char *GetTokenName(const TokenNode *tp);
+const char *GetTokenTypeName(TokenType type);
+
+#endif
+
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..d9c6e78
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,507 @@
+/****************************************************************************
+ * The main entry point and related JWM functions.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "main.h"
+#include "lex.h"
+#include "parse.h"
+#include "help.h"
+#include "error.h"
+#include "event.h"
+
+#include "border.h"
+#include "client.h"
+#include "color.h"
+#include "command.h"
+#include "cursor.h"
+#include "confirm.h"
+#include "font.h"
+#include "hint.h"
+#include "group.h"
+#include "key.h"
+#include "icon.h"
+#include "outline.h"
+#include "taskbar.h"
+#include "tray.h"
+#include "traybutton.h"
+#include "popup.h"
+#include "pager.h"
+#include "swallow.h"
+#include "screen.h"
+#include "root.h"
+#include "desktop.h"
+#include "place.h"
+#include "clock.h"
+#include "dock.h"
+#include "theme.h"
+#include "misc.h"
+
+Display *display = NULL;
+Window rootWindow;
+int rootWidth, rootHeight;
+int rootDepth;
+int rootScreen;
+Colormap rootColormap;
+Visual *rootVisual;
+GC rootGC;
+int colormapCount;
+
+int shouldExit = 0;
+int shouldRestart = 0;
+int isRestarting = 0;
+int initializing = 0;
+
+unsigned int desktopCount = 4;
+unsigned int currentDesktop = 0;
+
+char *exitCommand = NULL;
+
+int borderWidth = DEFAULT_BORDER_WIDTH;
+int titleHeight = DEFAULT_TITLE_HEIGHT;
+
+unsigned int doubleClickSpeed;
+unsigned int doubleClickDelta;
+
+FocusModelType focusModel = FOCUS_SLOPPY;
+
+XContext clientContext;
+XContext frameContext;
+
+#ifdef USE_SHAPE
+int haveShape;
+int shapeEvent;
+#endif
+
+
+static const char *CONFIG_FILE = "/.jwmrc";
+
+static void Initialize();
+static void Startup();
+static void Shutdown();
+static void Destroy();
+
+static void OpenConnection();
+static void CloseConnection();
+static void StartupConnection();
+static void ShutdownConnection();
+static void EventLoop();
+static void HandleExit();
+static void DoExit(int code);
+static void SendRestart();
+static void SendExit();
+
+static char *configPath = NULL;
+static char *displayString = NULL;
+
+/****************************************************************************
+ ****************************************************************************/
+int main(int argc, char *argv[]) {
+	char *temp;
+	int x;
+
+	StartDebug();
+
+	temp = getenv("HOME");
+	if(temp) {
+		configPath = Allocate(strlen(temp) + strlen(CONFIG_FILE) + 1);
+		strcpy(configPath, temp);
+		strcat(configPath, CONFIG_FILE);
+	} else {
+		configPath = CopyString(CONFIG_FILE);
+	}
+
+	for(x = 1; x < argc; x++) {
+		if(!strcmp(argv[x], "-v")) {
+			DisplayAbout();
+			DoExit(0);
+		} else if(!strcmp(argv[x], "-h")) {
+			DisplayHelp();
+			DoExit(0);
+		} else if(!strcmp(argv[x], "-p")) {
+			Initialize();
+			ParseConfig(configPath);
+			DoExit(0);
+		} else if(!strcmp(argv[x], "-restart")) {
+			SendRestart();
+			DoExit(0);
+		} else if(!strcmp(argv[x], "-exit")) {
+			SendExit();
+			DoExit(0);
+		} else if(!strcmp(argv[x], "-display") && x + 1 < argc) {
+			displayString = argv[++x];
+		} else {
+			DisplayUsage();
+			DoExit(1);
+		}
+	}
+
+	StartupConnection();
+	do {
+
+		isRestarting = shouldRestart;
+		shouldExit = 0;
+		shouldRestart = 0;
+
+		Initialize();
+
+		ParseConfig(configPath);
+
+		Startup();
+
+		EventLoop();
+
+		Shutdown();
+
+		Destroy();
+
+	} while(shouldRestart);
+	ShutdownConnection();
+
+	if(exitCommand) {
+		execl(SHELL_NAME, SHELL_NAME, "-c", exitCommand, NULL);
+		Warning("exec failed: (%s) %s", SHELL_NAME, exitCommand);
+		DoExit(1);
+	} else {
+		DoExit(0);
+	}
+
+	/* Control shoud never get here. */
+	return -1;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DoExit(int code) {
+	Destroy();
+
+	if(configPath) {
+		Release(configPath);
+		configPath = NULL;
+	}
+	if(exitCommand) {
+		Release(exitCommand);
+		exitCommand = NULL;
+	}
+
+	StopDebug();
+	exit(code);
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void EventLoop() {
+	XEvent event;
+
+	while(!shouldExit) {
+		WaitForEvent(&event);
+		ProcessEvent(&event);
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void OpenConnection() {
+
+	display = JXOpenDisplay(displayString);
+	if(!display) {
+		if(displayString) {
+			printf("error: could not open display %s\n", displayString);
+		} else {
+			printf("error: could not open display\n");
+		}
+		DoExit(1);
+	}
+
+	rootScreen = DefaultScreen(display);
+	rootWindow = RootWindow(display, rootScreen);
+	rootWidth = DisplayWidth(display, rootScreen);
+	rootHeight = DisplayHeight(display, rootScreen);
+	rootDepth = DefaultDepth(display, rootScreen);
+	rootColormap = DefaultColormap(display, rootScreen);
+	rootVisual = DefaultVisual(display, rootScreen);
+	rootGC = DefaultGC(display, rootScreen);
+	colormapCount = MaxCmapsOfScreen(ScreenOfDisplay(display, rootScreen));
+
+	XSetGraphicsExposures(display, rootGC, False);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupConnection() {
+	XSetWindowAttributes attr;
+	int temp;
+
+	initializing = 1;
+	OpenConnection();
+
+#if 0
+	XSynchronize(display, True);
+#endif
+
+	JXSetErrorHandler(ErrorHandler);
+
+	clientContext = XUniqueContext();
+	frameContext = XUniqueContext();
+
+	attr.event_mask
+		= SubstructureRedirectMask
+		| SubstructureNotifyMask
+		| PropertyChangeMask
+		| ColormapChangeMask
+		| ButtonPressMask
+		| ButtonReleaseMask
+		| PointerMotionMask | PointerMotionHintMask;
+	JXChangeWindowAttributes(display, rootWindow, CWEventMask, &attr);
+
+	signal(SIGTERM, HandleExit);
+	signal(SIGINT, HandleExit);
+	signal(SIGHUP, HandleExit);
+
+#ifdef USE_SHAPE
+	haveShape = JXShapeQueryExtension(display, &shapeEvent, &temp);
+	if (haveShape) {
+		Debug("shape extension enabled");
+	} else {
+		Debug("shape extension disabled");
+	}
+#endif
+
+	initializing = 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void CloseConnection() {
+	JXFlush(display);
+	JXCloseDisplay(display);
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownConnection() {
+	CloseConnection();
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void HandleExit() {
+	signal(SIGTERM, HandleExit);
+	signal(SIGINT, HandleExit);
+	signal(SIGHUP, HandleExit);
+	shouldExit = 1;
+}
+
+/****************************************************************************
+ * This is called before the X connection is opened.
+ ****************************************************************************/
+void Initialize() {
+	InitializeBorders();
+	InitializeClients();
+	InitializeClock();
+	InitializeColors();
+	InitializeCommands();
+	InitializeCursors();
+	InitializeDesktops();
+	#ifndef DISABLE_CONFIRM
+		InitializeDialogs();
+	#endif
+	InitializeDock();
+	InitializeFonts();
+	InitializeGroups();
+	InitializeHints();
+	InitializeIcons();
+	InitializeKeys();
+	InitializeOutline();
+	InitializePager();
+	InitializePlacement();
+	InitializePopup();
+	InitializeRootMenu();
+	InitializeScreens();
+	InitializeSwallow();
+	InitializeTaskBar();
+	InitializeThemes();
+	InitializeTray();
+	InitializeTrayButtons();
+}
+
+/****************************************************************************
+ * This is called after the X connection is opened.
+ ****************************************************************************/
+void Startup() {
+
+	/* This order is important. */
+
+	StartupCommands();
+
+	/* First we grab the server to prevent clients from changing things
+	 * while we're still loading. */
+	JXGrabServer(display);
+
+	StartupScreens();
+
+	StartupGroups();
+	StartupColors();
+	StartupIcons();
+	StartupFonts();
+	StartupCursors();
+	StartupOutline();
+
+	StartupThemes();
+
+	StartupPager();
+	StartupClock();
+	StartupTaskBar();
+	StartupTrayButtons();
+	StartupDock();
+	StartupTray();
+	StartupKeys();
+	StartupDesktops();
+	StartupHints();
+	StartupBorders();
+	StartupPlacement();
+	StartupClients();
+
+	#ifndef DISABLE_CONFIRM
+		StartupDialogs();
+	#endif
+	StartupPopup();
+
+	StartupRootMenu();
+
+	SetDefaultCursor(rootWindow);
+	ReadCurrentDesktop();
+	JXFlush(display);
+
+	RestackClients();
+
+	/* Allow clients to do their thing. */
+	JXSync(display, True);
+	JXUngrabServer(display);
+
+	StartupSwallow();
+
+	/* Send expose events. */
+	ExposeCurrentDesktop();
+
+}
+
+/****************************************************************************
+ * This is called before the X connection is closed.
+ ****************************************************************************/
+void Shutdown() {
+
+	/* This order is important. */
+
+	ShutdownSwallow();
+
+	ShutdownOutline();
+	#ifndef DISABLE_CONFIRM
+		ShutdownDialogs();
+	#endif
+	ShutdownPopup();
+	ShutdownKeys();
+	ShutdownPager();
+	ShutdownRootMenu();
+	ShutdownDock();
+	ShutdownTray();
+	ShutdownTrayButtons();
+	ShutdownTaskBar();
+	ShutdownClock();
+	ShutdownBorders();
+	ShutdownClients();
+	ShutdownThemes();
+	ShutdownIcons();
+	ShutdownCursors();
+	ShutdownFonts();
+	ShutdownColors();
+	ShutdownGroups();
+	ShutdownDesktops();
+
+	ShutdownPlacement();
+	ShutdownHints();
+	ShutdownScreens();
+
+	ShutdownCommands();
+
+}
+
+/****************************************************************************
+ * This is called after the X connection is closed.
+ * Note that it is possible for this to be called more than once.
+ ****************************************************************************/
+void Destroy() {
+	DestroyBorders();
+	DestroyClients();
+	DestroyClock();
+	DestroyColors();
+	DestroyCommands();
+	DestroyCursors();
+	DestroyDesktops();
+	#ifndef DISABLE_CONFIRM
+		DestroyDialogs();
+	#endif
+	DestroyDock();
+	DestroyFonts();
+	DestroyGroups();
+	DestroyHints();
+	DestroyIcons();
+	DestroyKeys();
+	DestroyOutline();
+	DestroyPager();
+	DestroyPlacement();
+	DestroyPopup();
+	DestroyRootMenu();
+	DestroyScreens();
+	DestroySwallow();
+	DestroyTaskBar();
+	DestroyThemes();
+	DestroyTray();
+	DestroyTrayButtons();
+}
+
+/****************************************************************************
+ * Send _JWM_RESTART to the root window.
+ ****************************************************************************/
+void SendRestart() {
+
+	XEvent event;
+
+	OpenConnection();
+
+	memset(&event, 0, sizeof(event));
+	event.xclient.type = ClientMessage;
+	event.xclient.window = rootWindow;
+	event.xclient.message_type = JXInternAtom(display, "_JWM_RESTART", False);
+	event.xclient.format = 32;
+
+	JXSendEvent(display, rootWindow, False, SubstructureRedirectMask, &event);
+
+	CloseConnection();
+
+}
+
+/****************************************************************************
+ * Send _JWM_EXIT to the root window.
+ ****************************************************************************/
+void SendExit() {
+
+	XEvent event;
+
+	OpenConnection();
+
+	memset(&event, 0, sizeof(event));
+	event.xclient.type = ClientMessage;
+	event.xclient.window = rootWindow;
+	event.xclient.message_type = JXInternAtom(display, "_JWM_EXIT", False);
+	event.xclient.format = 32;
+
+	JXSendEvent(display, rootWindow, False, SubstructureRedirectMask, &event);
+
+	CloseConnection();
+}
+
diff --git a/src/main.h b/src/main.h
new file mode 100644
index 0000000..2216de0
--- /dev/null
+++ b/src/main.h
@@ -0,0 +1,56 @@
+/**
+ * @file main.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the main functions.
+ *
+ */
+
+#ifndef MAIN_H
+#define MAIN_H
+
+typedef enum {
+	FOCUS_SLOPPY              = 0,
+	FOCUS_CLICK               = 1
+} FocusModelType;
+
+extern Display *display;
+extern Window rootWindow;
+extern int rootWidth, rootHeight;
+extern int rootDepth;
+extern int rootScreen;
+extern Colormap rootColormap;
+extern Visual *rootVisual;
+extern GC rootGC;
+extern int colormapCount;
+
+extern char *exitCommand;
+
+extern unsigned int desktopCount;
+extern unsigned int currentDesktop;
+
+extern int shouldExit;
+extern int shouldRestart;
+extern int isRestarting;
+
+extern int initializing;
+
+extern int borderWidth;
+extern int titleHeight;
+
+extern unsigned int doubleClickSpeed;
+extern unsigned int doubleClickDelta;
+
+extern FocusModelType focusModel;
+
+extern XContext clientContext;
+extern XContext frameContext;
+
+#ifdef USE_SHAPE
+extern int haveShape;
+extern int shapeEvent;
+#endif
+
+#endif
+
diff --git a/src/match.c b/src/match.c
new file mode 100644
index 0000000..95edd39
--- /dev/null
+++ b/src/match.c
@@ -0,0 +1,80 @@
+/****************************************************************************
+ * Expression matching.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "match.h"
+
+typedef struct MatchStateType {
+	const char *pattern;
+	const char *expression;
+	int patternOffset;
+	int expressionOffset;
+	int expressionLength;
+} MatchStateType;
+
+static int DoMatch(MatchStateType state);
+
+/****************************************************************************
+ ****************************************************************************/
+int Match(const char *pattern, const char *expression) {
+
+	MatchStateType state;
+
+	if(!pattern && !expression) {
+		return 1;
+	} else if(!pattern || !expression) {
+		return 0;
+	}
+
+	state.pattern = pattern;
+	state.expression = expression;
+	state.patternOffset = 0;
+	state.expressionOffset = 0;
+	state.expressionLength = strlen(expression);
+
+	return DoMatch(state);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int DoMatch(MatchStateType state) {
+
+	char p, e;
+
+	for(;;) {
+		p = state.pattern[state.patternOffset];
+		e = state.expression[state.expressionOffset];
+
+		if(p == 0 && e == 0) {
+			return 1;
+		} else if(p == 0 || e == 0) {
+			return 0;
+		}
+
+		switch(p) {
+		case '*':
+			++state.patternOffset;
+			while(state.expressionOffset < state.expressionLength) {
+				if(DoMatch(state)) {
+					return 1;
+				}
+				++state.expressionOffset;
+			}
+			return 0;
+		default:
+			if(p == e) {
+				++state.patternOffset;
+				++state.expressionOffset;
+				break;
+			} else {
+				return 0;
+			}
+		}
+	}
+
+}
+
+
diff --git a/src/match.h b/src/match.h
new file mode 100644
index 0000000..2cdb2e2
--- /dev/null
+++ b/src/match.h
@@ -0,0 +1,21 @@
+/**
+ * @file match.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Expression matching.
+ *
+ */
+
+#ifndef MATCH_H
+#define MATCH_H
+
+/** Check if an expression matches a pattern.
+ * @param pattern The pattern to match against.
+ * @param expression The expression to check.
+ * @return 1 if there is a match, 0 otherwise.
+ */
+int Match(const char *pattern, const char *expression);
+
+#endif
+
diff --git a/src/menu.c b/src/menu.c
new file mode 100644
index 0000000..9f6b80c
--- /dev/null
+++ b/src/menu.c
@@ -0,0 +1,799 @@
+/***************************************************************************
+ * Menu functions display and handling functions.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "menu.h"
+#include "font.h"
+#include "client.h"
+#include "color.h"
+#include "icon.h"
+#include "image.h"
+#include "main.h"
+#include "cursor.h"
+#include "key.h"
+#include "button.h"
+#include "event.h"
+
+#define BASE_ICON_OFFSET 3
+
+typedef enum {
+	MENU_NOSELECTION = 0,
+	MENU_LEAVE       = 1,
+	MENU_SUBSELECT   = 2
+} MenuSelectionType;
+
+/* Submenu arrow, 4 x 7 pixels */
+static char menu_bitmap[] = {
+	0x01, 0x03, 0x07, 0x0F, 0x07, 0x03, 0x01
+};
+
+static int ShowSubmenu(Menu *menu, Menu *parent, int x, int y);
+
+static void CreateMenu(Menu *menu, int x, int y);
+static void HideMenu(Menu *menu);
+static void DrawMenu(Menu *menu);
+static void RedrawMenuTree(Menu *menu);
+
+static int MenuLoop(Menu *menu);
+static MenuSelectionType UpdateMotion(Menu *menu, XEvent *event);
+
+static void UpdateMenu(Menu *menu);
+static void DrawMenuItem(Menu *menu, MenuItem *item, int index);
+static MenuItem *GetMenuItem(Menu *menu, int index);
+static int GetNextMenuIndex(Menu *menu);
+static int GetPreviousMenuIndex(Menu *menu);
+static int GetMenuIndex(Menu *menu, int index);
+static void SetPosition(Menu *tp, int index);
+
+static MenuAction *menuAction = NULL;
+
+int menuShown = 0;
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeMenu(Menu *menu) {
+
+	MenuItem *np;
+	int index, temp;
+	int hasSubmenu;
+	int userHeight;
+
+	menu->textOffset = 0;
+	menu->itemCount = 0;
+
+	/* Compute the max size needed */
+	userHeight = menu->itemHeight;
+	if(userHeight < 0) {
+		userHeight = 0;
+	}
+	menu->itemHeight = GetStringHeight(FONT_MENU);
+	for(np = menu->items; np; np = np->next) {
+		if(np->iconName) {
+			np->icon = LoadNamedIcon(np->iconName);
+			if(np->icon) {
+				if(userHeight == 0) {
+					if(menu->itemHeight < (int)np->icon->image->height) {
+						menu->itemHeight = np->icon->image->height;
+					}
+					if(menu->textOffset < (int)np->icon->image->width + 4) {
+						menu->textOffset = np->icon->image->width + 4;
+					}
+				}
+			}
+		} else {
+			np->icon = NULL;
+		}
+		++menu->itemCount;
+	}
+	menu->itemHeight += BASE_ICON_OFFSET * 2;
+
+	if(userHeight) {
+		menu->itemHeight = userHeight + BASE_ICON_OFFSET * 2;
+		menu->textOffset = menu->itemHeight + BASE_ICON_OFFSET * 2;
+	}
+
+	menu->width = 5;
+	menu->parent = NULL;
+	menu->parentOffset = 0;
+
+	menu->height = 1;
+	if(menu->label) {
+		menu->height += menu->itemHeight;
+	}
+
+	/* Nothing else to do if there is nothing in the menu. */
+	if(menu->itemCount == 0) {
+		return;
+	}
+
+	menu->offsets = Allocate(sizeof(int) * menu->itemCount);
+
+	hasSubmenu = 0;
+	index = 0;
+	for(np = menu->items; np; np = np->next) {
+		menu->offsets[index++] = menu->height;
+		if(np->type == MENU_ITEM_SEPARATOR) {
+			menu->height += 5;
+		} else {
+			menu->height += menu->itemHeight;
+		}
+		if(np->name) {
+			temp = GetStringWidth(FONT_MENU, np->name);
+			if(temp > menu->width) {
+				menu->width = temp;
+			}
+		}
+		if(np->submenu) {
+			hasSubmenu = 7;
+			InitializeMenu(np->submenu);
+		}
+	}
+	menu->height += 2;
+	menu->width += 15 + hasSubmenu + menu->textOffset;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShowMenu(Menu *menu, RunMenuCommandType runner, int x, int y) {
+
+	int mouseStatus, keyboardStatus;
+
+	mouseStatus = GrabMouseForMenu();
+	keyboardStatus = JXGrabKeyboard(display, rootWindow, False,
+		GrabModeAsync, GrabModeAsync, CurrentTime);
+	if(!mouseStatus || keyboardStatus != GrabSuccess) {
+		return;
+	}
+
+	ShowSubmenu(menu, NULL, x, y);
+
+	JXUngrabKeyboard(display, CurrentTime);
+	JXUngrabPointer(display, CurrentTime);
+	RefocusClient();
+
+	if(menuAction) {
+		(runner)(menuAction);
+		menuAction = NULL;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyMenu(Menu *menu) {
+	MenuItem *np;
+
+	if(menu) {
+		while(menu->items) {
+			np = menu->items->next;
+			if(menu->items->name) {
+				Release(menu->items->name);
+			}
+			switch(menu->items->action.type) {
+			case MA_EXECUTE:
+			case MA_EXIT:
+				if(menu->items->action.data.str) {
+					Release(menu->items->action.data.str);
+				}
+				break;
+			default:
+				break;
+			}
+			if(menu->items->iconName) {
+				Release(menu->items->iconName);
+			}
+			if(menu->items->submenu) {
+				DestroyMenu(menu->items->submenu);
+			}
+			Release(menu->items);
+			menu->items = np;
+		}
+		if(menu->label) {
+			Release(menu->label);
+		}
+		if(menu->offsets) {
+			Release(menu->offsets);
+		}
+		Release(menu);
+		menu = NULL;
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ShowSubmenu(Menu *menu, Menu *parent, int x, int y) {
+	int status;
+
+	menu->parent = parent;
+	CreateMenu(menu, x, y);
+
+	++menuShown;
+	status = MenuLoop(menu);
+	--menuShown;
+
+	HideMenu(menu);
+
+	return status;
+}
+
+/***************************************************************************
+ * Returns 0 if no selection was made or 1 if a selection was made.
+ ***************************************************************************/
+int MenuLoop(Menu *menu) {
+
+	XEvent event;
+	MenuItem *ip;
+	int count;
+	int hadMotion;
+	int pressx, pressy;
+
+	hadMotion = 0;
+
+	GetMousePosition(&pressx, &pressy);
+
+	for(;;) {
+
+		WaitForEvent(&event);
+
+		switch(event.type) {
+		case Expose:
+			RedrawMenuTree(menu);
+			break;
+
+		case ButtonPress:
+
+			pressx = -100;
+			pressy = -100;
+
+		case KeyPress:
+		case MotionNotify:
+			hadMotion = 1;
+			switch(UpdateMotion(menu, &event)) {
+			case MENU_NOSELECTION: /* no selection */
+				break;
+			case MENU_LEAVE: /* mouse left the menu */
+				JXPutBackEvent(display, &event);
+				return 0;
+			case MENU_SUBSELECT: /* selection made */
+				return 1;
+			}
+			break;
+
+		case ButtonRelease:
+
+			if(event.xbutton.button == Button4) {
+				break;
+			}
+			if(event.xbutton.button == Button5) {
+				break;
+			}
+			if(!hadMotion) {
+				break;
+			}
+			if(abs(event.xbutton.x_root - pressx) < doubleClickDelta) {
+				if(abs(event.xbutton.y_root - pressy) < doubleClickDelta) {
+					break;
+				}
+			}
+				
+			if(menu->currentIndex >= 0) {
+				count = 0;
+				for(ip = menu->items; ip; ip = ip->next) {
+					if(count == menu->currentIndex) {
+						menuAction = &ip->action;
+						break;
+					}
+					++count;
+				}
+			}
+			return 1;
+		default:
+			break;
+		}
+
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void CreateMenu(Menu *menu, int x, int y) {
+
+	XSetWindowAttributes attr;
+	unsigned long attrMask;
+	int temp;
+
+	menu->lastIndex = -1;
+	menu->currentIndex = -1;
+
+	if(x + menu->width > rootWidth) {
+		if(menu->parent) {
+			x = menu->parent->x - menu->width;
+		} else {
+			x = rootWidth - menu->width;
+		}
+	}
+	temp = y;
+	if(y + menu->height > rootHeight) {
+		y = rootHeight - menu->height;
+	}
+	if(y < 0) {
+		y = 0;
+	}
+
+	menu->x = x;
+	menu->y = y;
+	menu->parentOffset = temp - y;
+
+	attrMask = 0;
+
+	attrMask |= CWEventMask;
+	attr.event_mask = ExposureMask;
+
+	attrMask |= CWBackPixel;
+	attr.background_pixel = colors[COLOR_MENU_BG];
+
+	attrMask |= CWSaveUnder;
+	attr.save_under = True;
+
+	menu->window = JXCreateWindow(display, rootWindow, x, y,
+		menu->width, menu->height, 0, CopyFromParent, InputOutput,
+		CopyFromParent, attrMask, &attr);
+
+	JXMapRaised(display, menu->window);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void HideMenu(Menu *menu) {
+
+	JXDestroyWindow(display, menu->window);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void RedrawMenuTree(Menu *menu) {
+
+	if(menu->parent) {
+		RedrawMenuTree(menu->parent);
+	}
+
+	DrawMenu(menu);
+	UpdateMenu(menu);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DrawMenu(Menu *menu) {
+
+	MenuItem *np;
+	int x;
+
+	if(menu->label) {
+		DrawMenuItem(menu, NULL, -1);
+	}
+
+	x = 0;
+	for(np = menu->items; np; np = np->next) {
+		DrawMenuItem(menu, np, x);
+		++x;
+	}
+
+	JXSetForeground(display, rootGC, colors[COLOR_MENU_UP]);
+	JXDrawLine(display, menu->window, rootGC,
+		0, 0, menu->width - 1, 0);
+	JXDrawLine(display, menu->window, rootGC,
+		0, 1, menu->width - 2, 1);
+	JXDrawLine(display, menu->window, rootGC,
+		0, 2, 0, menu->height - 1);
+	JXDrawLine(display, menu->window, rootGC,
+		1, 2, 1, menu->height - 2);
+
+	JXSetForeground(display, rootGC, colors[COLOR_MENU_DOWN]);
+	JXDrawLine(display, menu->window, rootGC,
+		1, menu->height - 1, menu->width - 1, menu->height - 1);
+	JXDrawLine(display, menu->window, rootGC,
+		2, menu->height - 2, menu->width - 1, menu->height - 2);
+	JXDrawLine(display, menu->window, rootGC,
+		menu->width - 1, 1, menu->width - 1, menu->height - 3);
+	JXDrawLine(display, menu->window, rootGC,
+		menu->width - 2, 2, menu->width - 2, menu->height - 3);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+MenuSelectionType UpdateMotion(Menu *menu, XEvent *event) {
+
+	MenuItem *ip;
+	Menu *tp;
+	Window subwindow;
+	int x, y;
+
+	if(event->type == MotionNotify) {
+
+		SetMousePosition(event->xmotion.x_root, event->xmotion.y_root);
+		DiscardMotionEvents(event, menu->window);
+
+		x = event->xmotion.x_root - menu->x;
+		y = event->xmotion.y_root - menu->y;
+		subwindow = event->xmotion.subwindow;
+
+	} else if(event->type == ButtonPress) {
+
+		if(menu->currentIndex >= 0 || !menu->parent) {
+			tp = menu;
+		} else {
+			tp = menu->parent;
+		}
+
+		y = -1;
+		if(event->xbutton.button == Button4) {
+			y = GetPreviousMenuIndex(tp);
+		} else if(event->xbutton.button == Button5) {
+			y = GetNextMenuIndex(tp);
+		}
+
+		if(y >= 0) {
+			SetPosition(tp, y);
+		}
+
+		return MENU_NOSELECTION;
+
+	} else if(event->type == KeyPress) {
+
+		if(menu->currentIndex >= 0 || !menu->parent) {
+			tp = menu;
+		} else {
+			tp = menu->parent;
+		}
+
+		y = -1;
+		switch(GetKey(&event->xkey) & 0xFF) {
+		case KEY_UP:
+			y = GetPreviousMenuIndex(tp);
+			break;
+		case KEY_DOWN:
+			y = GetNextMenuIndex(tp);
+			break;
+		case KEY_RIGHT:
+			tp = menu;
+			y = 0;
+			break;
+		case KEY_LEFT:
+			if(tp->parent) {
+				tp = tp->parent;
+				if(tp->currentIndex >= 0) {
+					y = tp->currentIndex;
+				} else {
+					y = 0;
+				}
+			}
+			break;
+		case KEY_ESC:
+			return MENU_SUBSELECT;
+		case KEY_ENTER:
+			if(tp->currentIndex >= 0) {
+				x = 0;
+				for(ip = tp->items; ip; ip = ip->next) {
+					if(x == tp->currentIndex) {
+						menuAction = &ip->action;
+						break;
+					}
+					++x;
+				}
+			}
+			return MENU_SUBSELECT;
+		default:
+			break;
+		}
+
+		if(y >= 0) {
+			SetPosition(tp, y);
+		}
+
+		return MENU_NOSELECTION;
+
+	} else {
+		Debug("invalid event type in menu.c:UpdateMotion");
+		return MENU_SUBSELECT;
+	}
+
+	/* Update the selection on the current menu */
+	if(x > 0 && y > 0 && x < menu->width && y < menu->height) {
+		menu->currentIndex = GetMenuIndex(menu, y);
+	} else if(menu->parent && subwindow != menu->parent->window) {
+
+		/* Leave if over a menu window. */
+		for(tp = menu->parent->parent; tp; tp = tp->parent) {
+			if(tp->window == subwindow) {
+				return MENU_LEAVE;
+			}
+		}
+		menu->currentIndex = -1;
+
+	} else {
+
+		/* Leave if over the parent, but not on this selection. */
+		tp = menu->parent;
+		if(tp && subwindow == tp->window) {
+			if(y < menu->parentOffset
+				|| y > tp->itemHeight + menu->parentOffset) {
+				return MENU_LEAVE;
+			}
+		}
+
+		menu->currentIndex = -1;
+
+	}
+
+	/* Move the menu if needed. */
+	if(menu->height > rootHeight && menu->currentIndex >= 0) {
+
+		/* If near the top, shift down. */
+		if(y + menu->y <= 0) {
+			if(menu->currentIndex > 0) {
+				--menu->currentIndex;
+				SetPosition(menu, menu->currentIndex);
+			}
+		}
+
+		/* If near the bottom, shift up. */
+		if(y + menu->y + menu->itemHeight / 2 >= rootHeight) {
+			if(menu->currentIndex + 1 < menu->itemCount) {
+				++menu->currentIndex;
+				SetPosition(menu, menu->currentIndex);
+			}
+		}
+
+	}
+
+	if(menu->lastIndex != menu->currentIndex) {
+		UpdateMenu(menu);
+		menu->lastIndex = menu->currentIndex;
+	}
+
+	/* If the selected item is a submenu, show it. */
+	ip = GetMenuItem(menu, menu->currentIndex);
+	if(ip && ip->submenu) {
+		if(ShowSubmenu(ip->submenu, menu, menu->x + menu->width,
+			menu->y + menu->offsets[menu->currentIndex])) {
+
+			/* Item selected; destroy the menu tree. */
+			return MENU_SUBSELECT;
+
+		} else {
+
+			/* No selection made. */
+			UpdateMenu(menu);
+
+		}
+	}
+
+	return MENU_NOSELECTION;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void UpdateMenu(Menu *menu) {
+
+	ButtonNode button;
+	Pixmap pixmap;
+	MenuItem *ip;
+
+	/* Clear the old selection. */
+	ip = GetMenuItem(menu, menu->lastIndex);
+	DrawMenuItem(menu, ip, menu->lastIndex);
+
+	/* Highlight the new selection. */
+	ip = GetMenuItem(menu, menu->currentIndex);
+	if(ip) {
+
+		if(ip->type == MENU_ITEM_SEPARATOR) {
+			return;
+		}
+
+		ResetButton(&button, menu->window, rootGC);
+		button.type = BUTTON_MENU_ACTIVE;
+		button.font = FONT_MENU;
+		button.width = menu->width - 5;
+		button.height = menu->itemHeight - 2;
+		button.icon = ip->icon;
+		button.text = ip->name;
+		button.x = 2;
+		button.y = menu->offsets[menu->currentIndex] + 1;
+		DrawButton(&button);
+
+		if(ip->submenu) {
+			pixmap = JXCreatePixmapFromBitmapData(display, menu->window,
+				menu_bitmap, 4, 7, colors[COLOR_MENU_ACTIVE_FG],
+				colors[COLOR_MENU_ACTIVE_BG], rootDepth);
+			JXCopyArea(display, pixmap, menu->window, rootGC, 0, 0, 4, 7,
+				menu->width - 9,
+				menu->offsets[menu->currentIndex] + menu->itemHeight / 2 - 4);
+			JXFreePixmap(display, pixmap);
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DrawMenuItem(Menu *menu, MenuItem *item, int index) {
+
+	ButtonNode button;
+	Pixmap pixmap;
+
+	Assert(menu);
+
+	if(!item) {
+		if(index == -1 && menu->label) {
+			ResetButton(&button, menu->window, rootGC);
+			button.x = 2;
+			button.y = 2;
+			button.width = menu->width - 5;
+			button.height = menu->itemHeight - 2;
+			button.font = FONT_MENU;
+			button.type = BUTTON_LABEL;
+			button.text = menu->label;
+			button.alignment = ALIGN_CENTER;
+			DrawButton(&button);
+		}
+		return;
+	}
+
+	if(item->name) {
+
+		ResetButton(&button, menu->window, rootGC);
+		button.x = 2;
+		button.y = 1 + menu->offsets[index];
+		button.font = FONT_MENU;
+		button.type = BUTTON_LABEL;
+		button.width = menu->width - 5;
+		button.height = menu->itemHeight - 2;
+		button.text = item->name;
+		button.icon = item->icon;
+		DrawButton(&button);
+
+	} else if(item->type == MENU_ITEM_SEPARATOR) {
+
+		JXSetForeground(display, rootGC, colors[COLOR_MENU_DOWN]);
+		JXDrawLine(display, menu->window, rootGC, 4,
+			menu->offsets[index] + 2, menu->width - 6,
+			menu->offsets[index] + 2);
+		JXSetForeground(display, rootGC, colors[COLOR_MENU_UP]);
+		JXDrawLine(display, menu->window, rootGC, 4,
+			menu->offsets[index] + 3, menu->width - 6,
+			menu->offsets[index] + 3);
+
+	}
+
+	if(item->submenu) {
+
+		pixmap = JXCreatePixmapFromBitmapData(display, menu->window,
+			menu_bitmap, 4, 7, colors[COLOR_MENU_FG],
+			colors[COLOR_MENU_BG], rootDepth);
+		JXCopyArea(display, pixmap, menu->window, rootGC, 0, 0, 4, 7,
+			menu->width - 9, menu->offsets[index] + menu->itemHeight / 2 - 4);
+		JXFreePixmap(display, pixmap);
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int GetNextMenuIndex(Menu *menu) {
+
+	MenuItem *item;
+	int x;
+
+	for(x = menu->currentIndex + 1; x < menu->itemCount; x++) {
+		item = GetMenuItem(menu, x);
+		if(item->type != MENU_ITEM_SEPARATOR) {
+			return x;
+		}
+	}
+
+	return 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int GetPreviousMenuIndex(Menu *menu) {
+
+	MenuItem *item;
+	int x;
+
+	for(x = menu->currentIndex - 1; x >= 0; x--) {
+		item = GetMenuItem(menu, x);
+		if(item->type != MENU_ITEM_SEPARATOR) {
+			return x;
+		}
+	}
+
+	return menu->itemCount - 1;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int GetMenuIndex(Menu *menu, int y) {
+
+	int x;
+
+	if(y < menu->offsets[0]) {
+		return -1;
+	}
+	for(x = 0; x < menu->itemCount - 1; x++) {
+		if(y >= menu->offsets[x] && y < menu->offsets[x + 1]) {
+			return x;
+		}
+	}
+	return x;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+MenuItem *GetMenuItem(Menu *menu, int index) {
+
+	MenuItem *ip;
+
+	if(index >= 0) {
+		for(ip = menu->items; ip; ip = ip->next) {
+			if(!index) {
+				return ip;
+			}
+			--index;
+		}
+	} else {
+		ip = NULL;
+	}
+
+	return ip;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetPosition(Menu *tp, int index) {
+
+	int y;
+	int updated;
+
+	y = tp->offsets[index] + tp->itemHeight / 2;
+
+	if(tp->height > rootHeight) {
+
+		updated = 0;
+		while(y + tp->y < tp->itemHeight / 2) {
+			tp->y += tp->itemHeight;
+			updated = tp->itemHeight;
+		}
+		while(y + tp->y >= rootHeight) {
+			tp->y -= tp->itemHeight;
+			updated = -tp->itemHeight;
+		}
+		if(updated) {
+			JXMoveWindow(display, tp->window, tp->x, tp->y);
+			y += updated;
+		}
+
+	}
+
+	/* We need to do this twice so the event gets registered
+	 * on the submenu if one exists. */
+	MoveMouse(tp->window, 6, y);
+	MoveMouse(tp->window, 6, y);
+
+}
+
+
diff --git a/src/menu.h b/src/menu.h
new file mode 100644
index 0000000..5d4ad94
--- /dev/null
+++ b/src/menu.h
@@ -0,0 +1,89 @@
+/**
+ * @file menu.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the menu functions.
+ *
+ */
+
+#ifndef MENU_H
+#define MENU_H
+
+typedef enum {
+	MA_NONE,
+	MA_EXECUTE,
+	MA_DESKTOP,
+	MA_SENDTO,
+	MA_LAYER,
+	MA_STICK,
+	MA_MAXIMIZE,
+	MA_MINIMIZE,
+	MA_RESTORE,
+	MA_SHADE,
+	MA_MOVE,
+	MA_RESIZE,
+	MA_KILL,
+	MA_CLOSE,
+	MA_EXIT,
+	MA_RESTART
+} MenuActionType;
+
+typedef struct MenuAction {
+	MenuActionType type;
+	union {
+		int i;
+		char *str;
+	} data;
+} MenuAction;
+
+typedef enum {
+	MENU_ITEM_NORMAL,
+	MENU_ITEM_SUBMENU,
+	MENU_ITEM_SEPARATOR
+} MenuItemType;
+
+typedef struct MenuItem {
+
+	MenuItemType type;
+	char *name;
+	MenuAction action;
+	char *iconName;
+	struct Menu *submenu;
+	struct MenuItem *next;
+
+	/* This field is handled by menu.c */
+	struct IconNode *icon;
+
+} MenuItem;
+
+typedef struct Menu {
+
+	/* These fields must be set before calling ShowMenu */
+	struct MenuItem *items;
+	char *label;
+	int itemHeight;
+
+	/* These fields are handled by menu.c */
+	Window window;
+	int x, y;
+	int width, height;
+	int currentIndex, lastIndex;
+	unsigned int itemCount;
+	int parentOffset;
+	int textOffset;
+	int *offsets;
+	struct Menu *parent;
+
+} Menu;
+
+typedef void (*RunMenuCommandType)(const MenuAction *action);
+
+void InitializeMenu(Menu *menu);
+void ShowMenu(Menu *menu, RunMenuCommandType runner, int x, int y);
+void DestroyMenu(Menu *menu);
+
+extern int menuShown;
+
+#endif
+
diff --git a/src/misc.c b/src/misc.c
new file mode 100644
index 0000000..5728323
--- /dev/null
+++ b/src/misc.c
@@ -0,0 +1,196 @@
+/**
+ * @file misc.c
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Miscellaneous functions and macros.
+ *
+ */
+
+#include "jwm.h"
+#include "misc.h"
+
+static int IsSpace(char ch);
+static int IsSymbolic(char ch);
+static char *GetSymbolName(const char *str);
+static void ReplaceSymbol(char **str, const char *name, const char *value);
+
+/** Determine if a character is a space character. */
+int IsSpace(char ch) {
+	switch(ch) {
+	case ' ':
+	case '\t':
+	case '\n':
+	case '\r':
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+/** Determine if a character is a valid for a shell variable. */
+int IsSymbolic(char ch) {
+
+	if(ch >= 'A' && ch <= 'Z') {
+		return 1;
+	} else if(ch >= 'a' && ch <= 'z') {
+		return 1;
+	} else if(ch >= '0' && ch <= '9') {
+		return 1;
+	} else if(ch == '_') {
+		return 1;
+	} else {
+		return 0;
+	}
+
+}
+
+/** Get the name of a shell variable (returns a copy). */
+char *GetSymbolName(const char *str) {
+
+	char *temp;
+	int stop;
+
+	if(*str == '$') {
+		temp = Allocate(2);
+		temp[0] = '$';
+		temp[1] = 0;
+	} else {
+		for(stop = 0; IsSymbolic(str[stop]); stop++);
+		temp = Allocate(stop + 1);
+		memcpy(temp, str, stop);
+		temp[stop] = 0;
+	}
+
+	return temp;
+
+}
+
+/** Replace "name" with "value" in str (reallocates if needed). */
+void ReplaceSymbol(char **str, const char *name, const char *value) {
+
+	char *temp;
+	int strLength;
+	int nameLength;
+	int valueLength;
+	int x;
+
+	Assert(str);
+	Assert(name);
+
+	strLength = strlen(*str);
+	nameLength = strlen(name) + 1;
+	if(value) {
+		valueLength = strlen(value);
+	} else {
+		valueLength = 0;
+	}
+
+	if(valueLength > nameLength) {
+		temp = Allocate(strLength - nameLength + valueLength + 1);
+		strcpy(temp, *str);
+		Release(*str);
+		*str = temp;
+	}
+
+	temp = strstr(*str, name);
+	Assert(temp);
+	--temp; /* Account for the "$" */
+
+	if(nameLength > valueLength) {
+
+		/* Move left */
+		for(x = 0; temp[x]; x++) {
+			temp[x] = temp[x + nameLength - valueLength];
+		}
+		temp[x] = temp[x + nameLength - valueLength];
+
+	} else if(nameLength < valueLength) {
+
+		/* Move right */
+		for(x = strlen(temp); x >= 0; x--) {
+			temp[x + valueLength - nameLength] = temp[x];
+		}
+
+	}
+
+
+	if(value) {
+		memcpy(temp, value, valueLength);
+	}
+
+}
+
+/** Perform shell-like macro path expansion. */
+void ExpandPath(char **path) {
+
+	char *name;
+	char *value;
+	int x;
+
+	Assert(path);
+
+	for(x = 0; (*path)[x]; x++) {
+
+		if((*path)[x] == '$') {
+			name = GetSymbolName(*path + x + 1);
+			value = getenv(name);
+			ReplaceSymbol(path, name, value);
+			Release(name);
+			if(value) {
+				x += strlen(value) - 1;
+			}
+		}
+
+	}
+
+}
+
+/** Trim leading and trailing whitespace from a string. */
+void Trim(char *str) {
+
+	int length;
+	int start;
+	int x;
+
+	Assert(str);
+
+	length = strlen(str);
+
+	/* Determine how much to cut off of the left. */
+	for(start = 0; IsSpace(str[start]); start++);
+
+	/* Trim the left. */
+	if(start > 0) {
+		length -= start;
+		for(x = 0; x < length + 1; x++) {
+			str[x] = str[x + start];
+		}
+	}
+
+	/* Trim the right. */
+	while(IsSpace(str[length - 1])) {
+		--length;
+		str[length] = 0;
+	}
+
+}
+
+/** Copy a string. */
+char *CopyString(const char *str) {
+
+	char *temp;
+	int len;
+
+	if(!str) {
+		return NULL;
+	}
+
+	len = strlen(str) + 1;
+	temp = Allocate(len);
+	memcpy(temp, str, len);
+
+	return temp;
+
+}
+
diff --git a/src/misc.h b/src/misc.h
new file mode 100644
index 0000000..c97a59e
--- /dev/null
+++ b/src/misc.h
@@ -0,0 +1,37 @@
+/**
+ * @file misc.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Miscellaneous functions and macros.
+ *
+ */
+
+#ifndef MISC_H
+#define MISC_H
+
+/** Return the minimum of two values. */
+#define Min( x, y ) ( (x) > (y) ? (y) : (x) )
+
+/** Return the maximum of two values. */
+#define Max( x, y ) ( (x) > (y) ? (x) : (y) )
+
+/** Perform shell-like macro path expansion.
+ * @param path The path to expand (possibly reallocated).
+ */
+void ExpandPath(char **path);
+
+/** Trim leading and trailing whitespace from a string.
+ * @param str The string to trim.
+ */
+void Trim(char *str);
+
+/** Copy a string.
+ * Note that NULL is accepted. When provided NULL, NULL will be returned.
+ * @param str The string to copy.
+ * @return A copy of the string.
+ */
+char *CopyString(const char *str);
+
+#endif
+
diff --git a/src/move.c b/src/move.c
new file mode 100644
index 0000000..882ac90
--- /dev/null
+++ b/src/move.c
@@ -0,0 +1,729 @@
+/****************************************************************************
+ * Functions to handle moving client windows.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "move.h"
+#include "client.h"
+#include "border.h"
+#include "outline.h"
+#include "error.h"
+#include "screen.h"
+#include "main.h"
+#include "cursor.h"
+#include "event.h"
+#include "pager.h"
+#include "key.h"
+#include "tray.h"
+#include "status.h"
+
+typedef struct {
+	int valid;
+	int left, right;
+	int top, bottom;
+} RectangleType;
+
+static int shouldStopMove;
+static SnapModeType snapMode = SNAP_BORDER;
+static int snapDistance = DEFAULT_SNAP_DISTANCE;
+
+static MoveModeType moveMode = MOVE_OPAQUE;
+
+static void StopMove(ClientNode *np, int doMove, int oldx, int oldy);
+static void MoveController(int wasDestroyed);
+
+static void DoSnap(ClientNode *np, int north, int west);
+static void DoSnapScreen(ClientNode *np, int north, int west);
+static void DoSnapBorder(ClientNode *np, int north, int west);
+static int ShouldSnap(const ClientNode *np);
+static void GetClientRectangle(const ClientNode *np, RectangleType *r);
+
+static int CheckOverlapTopBottom(const RectangleType *a,
+	const RectangleType *b);
+static int CheckOverlapLeftRight(const RectangleType *a,
+	const RectangleType *b);
+
+static int CheckLeftValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *left);
+static int CheckRightValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *right);
+static int CheckTopValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *top);
+static int CheckBottomValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *bottom);
+
+/****************************************************************************
+ ****************************************************************************/
+void SetSnapMode(SnapModeType mode) {
+	snapMode = mode;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetMoveMode(MoveModeType mode) {
+	moveMode = mode;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetSnapDistance(const char *value) {
+	int temp;
+
+	Assert(value);
+
+	temp = atoi(value);
+	if(temp > MAX_SNAP_DISTANCE || temp < MIN_SNAP_DISTANCE) {
+		snapDistance = DEFAULT_SNAP_DISTANCE;
+		Warning("invalid snap distance specified: %d", temp);
+	} else {
+		snapDistance = temp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetDefaultSnapDistance() {
+	snapDistance = DEFAULT_SNAP_DISTANCE;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void MoveController(int wasDestroyed) {
+
+	if(moveMode == MOVE_OUTLINE) {
+		ClearOutline();
+	}
+
+	JXUngrabPointer(display, CurrentTime);
+	JXUngrabKeyboard(display, CurrentTime);
+
+	DestroyMoveWindow();
+	shouldStopMove = 1;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int MoveClient(ClientNode *np, int startx, int starty) {
+
+	XEvent event;
+	int oldx, oldy;
+	int doMove;
+	int north, south, east, west;
+	int height;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_MOVE)) {
+		return 0;
+	}
+
+	GrabMouseForMove();
+
+	np->controller = MoveController;
+	shouldStopMove = 0;
+
+	oldx = np->x;
+	oldy = np->y;
+
+	if(!(GetMouseMask() & (Button1Mask | Button2Mask))) {
+		StopMove(np, 0, oldx, oldy);
+		return 0;
+	}
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	startx -= west;
+	starty -= north;
+
+	doMove = 0;
+	for(;;) {
+
+		WaitForEvent(&event);
+
+		if(shouldStopMove) {
+			np->controller = NULL;
+			SetDefaultCursor(np->parent);
+			return doMove;
+		}
+
+		switch(event.type) {
+		case ButtonRelease:
+			if(event.xbutton.button == Button1
+				|| event.xbutton.button == Button2) {
+				StopMove(np, doMove, oldx, oldy);
+				return doMove;
+			}
+			break;
+		case MotionNotify:
+
+			DiscardMotionEvents(&event, np->window);
+
+			np->x = event.xmotion.x_root - startx;
+			np->y = event.xmotion.y_root - starty;
+
+			DoSnap(np, north, west);
+
+			if(!doMove && (abs(np->x - oldx) > MOVE_DELTA
+				|| abs(np->y - oldy) > MOVE_DELTA)) {
+
+				if(np->state.status & STAT_MAXIMIZED) {
+					MaximizeClient(np);
+					startx = west + np->width / 2;
+					starty = north / 2;
+					MoveMouse(np->parent, startx, starty);
+				}
+
+				CreateMoveWindow(np);
+				doMove = 1;
+			}
+
+			if(doMove) {
+
+				if(moveMode == MOVE_OUTLINE) {
+					ClearOutline();
+					height = north + south;
+					if(!(np->state.status & STAT_SHADED)) {
+						height += np->height;
+					}
+					DrawOutline(np->x - west, np->y - north,
+						np->width + west + east, height);
+				} else {
+					JXMoveWindow(display, np->parent, np->x - west,
+						np->y - north);
+					SendConfigureEvent(np);
+				}
+				UpdateMoveWindow(np);
+				UpdatePager();
+			}
+
+			break;
+		default:
+			break;
+		}
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int MoveClientKeyboard(ClientNode *np) {
+
+	XEvent event;
+	int oldx, oldy;
+	int moved;
+	int height;
+	int north, south, east, west;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_MOVE)) {
+		return 0;
+	}
+
+	if(np->state.status & STAT_MAXIMIZED) {
+		MaximizeClient(np);
+	}
+
+	GrabMouseForMove();
+	if(JXGrabKeyboard(display, np->window, True, GrabModeAsync,
+		GrabModeAsync, CurrentTime) != GrabSuccess) {
+		Debug("could not grab keyboard for client move");
+		return 0;
+	}
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	oldx = np->x;
+	oldy = np->y;
+
+	np->controller = MoveController;
+	shouldStopMove = 0;
+
+	CreateMoveWindow(np);
+	UpdateMoveWindow(np);
+
+	MoveMouse(rootWindow, np->x, np->y);
+	DiscardMotionEvents(&event, np->window);
+
+	if(np->state.status & STAT_SHADED) {
+		height = 0;
+	} else {
+		height = np->height;
+	}
+
+	for(;;) {
+
+		WaitForEvent(&event);
+
+		if(shouldStopMove) {
+			np->controller = NULL;
+			SetDefaultCursor(np->parent);
+			return 1;
+		}
+
+		moved = 0;
+
+		if(event.type == KeyPress) {
+
+			while(JXCheckTypedWindowEvent(display, np->window, KeyPress, &event));
+
+			switch(GetKey(&event.xkey) & 0xFF) {
+			case KEY_UP:
+				if(np->y + height > 0) {
+					np->y -= 10;
+				}
+				break;
+			case KEY_DOWN:
+				if(np->y < rootHeight) {
+					np->y += 10;
+				}
+				break;
+			case KEY_RIGHT:
+				if(np->x < rootWidth) {
+					np->x += 10;
+				}
+				break;
+			case KEY_LEFT:
+				if(np->x + np->width > 0) {
+					np->x -= 10;
+				}
+				break;
+			default:
+				StopMove(np, 1, oldx, oldy);
+				return 1;
+			}
+
+			MoveMouse(rootWindow, np->x, np->y);
+			JXCheckTypedWindowEvent(display, np->window, MotionNotify, &event);
+
+			moved = 1;
+
+		} else if(event.type == MotionNotify) {
+
+			while(JXCheckTypedWindowEvent(display, np->window,
+				MotionNotify, &event));
+
+			np->x = event.xmotion.x;
+			np->y = event.xmotion.y;
+
+			moved = 1;
+
+		} else if(event.type == ButtonRelease) {
+
+			StopMove(np, 1, oldx, oldy);
+			return 1;
+
+		}
+
+		if(moved) {
+
+			if(moveMode == MOVE_OUTLINE) {
+				ClearOutline();
+				DrawOutline(np->x - west, np->y - west,
+					np->width + west + east, height + north + west);
+			} else {
+				JXMoveWindow(display, np->parent, np->x - west, np->y - north);
+				SendConfigureEvent(np);
+			}
+
+			UpdateMoveWindow(np);
+			UpdatePager();
+
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StopMove(ClientNode *np, int doMove, int oldx, int oldy) {
+
+	int north, south, east, west;
+
+	Assert(np);
+	Assert(np->controller);
+
+	(np->controller)(0);
+
+	np->controller = NULL;
+
+	SetDefaultCursor(np->parent);
+
+	if(!doMove) {
+		np->x = oldx;
+		np->y = oldy;
+		return;
+	}
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	JXMoveWindow(display, np->parent, np->x - west, np->y - north);
+	SendConfigureEvent(np);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DoSnap(ClientNode *np, int north, int west) {
+	switch(snapMode) {
+	case SNAP_BORDER:
+		DoSnapBorder(np, north, west);
+		DoSnapScreen(np, north, west);
+		break;
+	case SNAP_SCREEN:
+		DoSnapScreen(np, north, west);
+		break;
+	default:
+		break;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DoSnapScreen(ClientNode *np, int north, int west) {
+
+	RectangleType client;
+	int screen;
+	const ScreenType *sp;
+	int screenCount;
+
+	GetClientRectangle(np, &client);
+
+	screenCount = GetScreenCount();
+	for(screen = 0; screen < screenCount; screen++) {
+
+		sp = GetScreen(screen);
+
+		if(abs(client.right - sp->width - sp->x) <= snapDistance) {
+			np->x = sp->x + sp->width - west - np->width;
+		}
+		if(abs(client.left - sp->x) <= snapDistance) {
+			np->x = sp->x + west;
+		}
+		if(abs(client.bottom - sp->height - sp->y) <= snapDistance) {
+			np->y = sp->y + sp->height - west;
+			if(!(np->state.status & STAT_SHADED)) {
+				np->y -= np->height;
+			}
+		}
+		if(abs(client.top - sp->y) <= snapDistance) {
+			np->y = north + sp->y;
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DoSnapBorder(ClientNode *np, int north, int west) {
+
+	const ClientNode *tp;
+	const TrayType *tray;
+	RectangleType client, other;
+	RectangleType left = { 0 };
+	RectangleType right = { 0 };
+	RectangleType top = { 0 };
+	RectangleType bottom = { 0 };
+	int layer;
+
+	GetClientRectangle(np, &client);
+
+	other.valid = 1;
+
+	/* Work from the bottom of the window stack to the top. */
+	for(layer = 0; layer < LAYER_COUNT; layer++) {
+
+		/* Check tray windows. */
+		for(tray = GetTrays(); tray; tray = tray->next) {
+
+			if(tray->hidden) {
+				continue;
+			}
+
+			other.left = tray->x;
+			other.right = tray->x + tray->width;
+			other.top = tray->y;
+			other.bottom = tray->y + tray->height;
+
+			left.valid = CheckLeftValid(&client, &other, &left);
+			right.valid = CheckRightValid(&client, &other, &right);
+			top.valid = CheckTopValid(&client, &other, &top);
+			bottom.valid = CheckBottomValid(&client, &other, &bottom);
+
+			if(CheckOverlapTopBottom(&client, &other)) {
+				if(abs(client.left - other.right) <= snapDistance) {
+					left = other;
+				}
+				if(abs(client.right - other.left) <= snapDistance) {
+					right = other;
+				}
+			}
+			if(CheckOverlapLeftRight(&client, &other)) {
+				if(abs(client.top - other.bottom) <= snapDistance) {
+					top = other;
+				}
+				if(abs(client.bottom - other.top) <= snapDistance) {
+					bottom = other;
+				}
+			}
+
+		}
+
+		/* Check client windows. */
+		for(tp = nodeTail[layer]; tp; tp = tp->prev) {
+
+			if(tp == np || !ShouldSnap(tp)) {
+				continue;
+			}
+
+			GetClientRectangle(tp, &other);
+
+			/* Check if this border invalidates any previous value. */
+			left.valid = CheckLeftValid(&client, &other, &left);
+			right.valid = CheckRightValid(&client, &other, &right);
+			top.valid = CheckTopValid(&client, &other, &top);
+			bottom.valid = CheckBottomValid(&client, &other, &bottom);
+
+			/* Compute the new snap values. */
+			if(CheckOverlapTopBottom(&client, &other)) {
+				if(abs(client.left - other.right) <= snapDistance) {
+					left = other;
+				}
+				if(abs(client.right - other.left) <= snapDistance) {
+					right = other;
+				}
+			}
+			if(CheckOverlapLeftRight(&client, &other)) {
+				if(abs(client.top - other.bottom) <= snapDistance) {
+					top = other;
+				}
+				if(abs(client.bottom - other.top) <= snapDistance) {
+					bottom = other;
+				}
+			}
+
+		}
+
+	}
+
+	if(right.valid) {
+		np->x = right.left - np->width - west;
+	}
+	if(left.valid) {
+		np->x = left.right + west;
+	}
+	if(bottom.valid) {
+		np->y = bottom.top - west;
+		if(!(np->state.status & STAT_SHADED)) {
+			np->y -= np->height;
+		}
+	}
+	if(top.valid) {
+		np->y = top.bottom + north;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int ShouldSnap(const ClientNode *np) {
+	if(np->state.status & STAT_HIDDEN) {
+		return 0;
+	} else if(np->state.status & STAT_MINIMIZED) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void GetClientRectangle(const ClientNode *np, RectangleType *r) {
+
+	int border;
+
+	r->left = np->x;
+	r->right = np->x + np->width;
+	r->top = np->y;
+	if(np->state.status & STAT_SHADED) {
+		r->bottom = np->y;
+	} else {
+		r->bottom = np->y + np->height;
+	}
+
+	if(np->state.border & BORDER_OUTLINE) {
+		border = borderWidth;
+		r->left -= border;
+		r->right += border;
+		r->bottom += border;
+	} else {
+		border = 0;
+	}
+
+	if(np->state.border & BORDER_TITLE) {
+		r->top -= titleHeight + border;
+	} else {
+		r->top -= border;
+	}
+
+	r->valid = 1;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int CheckOverlapTopBottom(const RectangleType *a, const RectangleType *b) {
+	if(a->top >= b->bottom) {
+		return 0;
+	} else if(a->bottom <= b->top) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int CheckOverlapLeftRight(const RectangleType *a, const RectangleType *b) {
+	if(a->left >= b->right) {
+		return 0;
+	} else if(a->right <= b->left) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+/****************************************************************************
+ * Check if the current left snap position is valid.
+ * client - The window being moved.
+ * other  - A window higher in stacking order than previously check windows.
+ * left   - The top/bottom of the current left snap window.
+ * Returns 1 if the current left snap position is still valid, otherwise 0.
+ ****************************************************************************/
+int CheckLeftValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *left) {
+
+	if(!left->valid) {
+		return 0;
+	}
+
+	if(left->right > other->right) {
+		return 1;
+	}
+
+	/* If left and client go higher than other then still valid. */
+	if(left->top < other->top && client->top < other->top) {
+		return 1;
+	}
+
+	/* If left and client go lower than other then still valid. */
+	if(left->bottom > other->bottom && client->bottom > other->bottom) {
+		return 1;
+	}
+
+	if(other->left >= left->right) {
+		return 1;
+	}
+
+	return 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int CheckRightValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *right) {
+
+	if(!right->valid) {
+		return 0;
+	}
+
+	if(right->left < other->left) {
+		return 1;
+	}
+
+	/* If right and client go higher than other then still valid. */
+	if(right->top < other->top && client->top < other->top) {
+		return 1;
+	}
+
+	/* If right and client go lower than other then still valid. */
+	if(right->bottom > other->bottom && client->bottom > other->bottom) {
+		return 1;
+	}
+
+	if(other->right <= right->left) {
+		return 1;
+	}
+
+	return 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int CheckTopValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *top) {
+
+	if(!top->valid) {
+		return 0;
+	}
+
+	if(top->bottom > other->bottom) {
+		return 1;
+	}
+
+	/* If top and client are to the left of other then still valid. */
+	if(top->left < other->left && client->left < other->left) {
+		return 1;
+	}
+
+	/* If top and client are to the right of other then still valid. */
+	if(top->right > other->right && client->right > other->right) {
+		return 1;
+	}
+
+	if(other->top >= top->bottom) {
+		return 1;
+	}
+
+	return 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int CheckBottomValid(const RectangleType *client,
+	const RectangleType *other, const RectangleType *bottom) {
+
+	if(!bottom->valid) {
+		return 0;
+	}
+
+	if(bottom->top < other->top) {
+		return 1;
+	}
+
+	/* If bottom and client are to the left of other then still valid. */
+	if(bottom->left < other->left && client->left < other->left) {
+		return 1;
+	}
+
+	/* If bottom and client are to the right of other then still valid. */
+	if(bottom->right > other->right && client->right > other->right) {
+		return 1;
+	}
+
+	if(other->bottom <= bottom->top) {
+		return 1;
+	}
+
+	return 0;
+
+}
+
diff --git a/src/move.h b/src/move.h
new file mode 100644
index 0000000..8a737ff
--- /dev/null
+++ b/src/move.h
@@ -0,0 +1,61 @@
+/**
+ * @file move.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for client window move functions.
+ *
+ */
+
+#ifndef MOVE_H
+#define MOVE_H
+
+struct ClientNode;
+
+/** Window snap modes. */
+typedef enum {
+	SNAP_NONE                 = 0,  /**< Don't snap. */
+	SNAP_SCREEN               = 1,  /**< Snap to the edges of the screen. */
+	SNAP_BORDER               = 2   /**< Snap to all borders. */
+} SnapModeType;
+
+/** Window move modes. */
+typedef enum {
+	MOVE_OPAQUE,   /**< Show window contents while moving. */
+	MOVE_OUTLINE   /**< Show an outline while moving. */
+} MoveModeType;
+
+/** Move a client window.
+ * @param np The client to move.
+ * @param startx The starting mouse x-coordinate (window relative).
+ * @param starty The starting mouse y-coordinate (window relative).
+ * @return 1 if the client moved, 0 otherwise.
+ */
+int MoveClient(struct ClientNode *np, int startx, int starty);
+
+/** Move a client window using the keyboard (mouse optional).
+ * @param np The client to move.
+ * @return 1 if the client moved, 0 otherwise.
+ */
+int MoveClientKeyboard(struct ClientNode *np);
+
+/** Set the snap mode to use.
+ * @param mode The snap mode to use.
+ */
+void SetSnapMode(SnapModeType mode);
+
+/** Set the snap distance to use.
+ * @param value A string representation of the distance to use.
+ */
+void SetSnapDistance(const char *value);
+
+/** Set the snap distance to the default. */
+void SetDefaultSnapDistance();
+
+/** Set the move mode to use.
+ * @param mode The move mode to use.
+ */
+void SetMoveMode(MoveModeType mode);
+
+#endif
+
diff --git a/src/outline.c b/src/outline.c
new file mode 100644
index 0000000..b42e70a
--- /dev/null
+++ b/src/outline.c
@@ -0,0 +1,73 @@
+/****************************************************************************
+ * Outlines for moving and resizing.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "outline.h"
+#include "main.h"
+
+static GC outlineGC;
+
+static int lastX, lastY;
+static int lastWidth, lastHeight;
+static int outlineDrawn;
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeOutline() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupOutline() {
+
+	XGCValues gcValues;
+
+	gcValues.function = GXinvert;
+	gcValues.subwindow_mode = IncludeInferiors;
+	gcValues.line_width = 2;
+	outlineGC = JXCreateGC(display, rootWindow,
+		GCFunction | GCSubwindowMode | GCLineWidth, &gcValues);
+	outlineDrawn = 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownOutline() {
+	JXFreeGC(display, outlineGC);
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyOutline() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DrawOutline(int x, int y, int width, int height) {
+	if(!outlineDrawn) {
+		JXSync(display, False);
+		JXGrabServer(display);
+		JXDrawRectangle(display, rootWindow, outlineGC, x, y, width, height);
+		lastX = x;
+		lastY = y;
+		lastWidth = width;
+		lastHeight = height;
+		outlineDrawn = 1;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ClearOutline() {
+	if(outlineDrawn) {
+		JXDrawRectangle(display, rootWindow, outlineGC,
+			lastX, lastY, lastWidth, lastHeight);
+		outlineDrawn = 0;
+		JXUngrabServer(display);
+		JXSync(display, False);
+	}
+}
+
diff --git a/src/outline.h b/src/outline.h
new file mode 100644
index 0000000..26a4a5e
--- /dev/null
+++ b/src/outline.h
@@ -0,0 +1,32 @@
+/**
+ * @file outline.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Outlines for moving and resizing client windows.
+ *
+ */
+
+#ifndef OUTLINE_H
+#define OUTLINE_H
+
+/*@{*/
+void InitializeOutline();
+void StartupOutline();
+void ShutdownOutline();
+void DestroyOutline();
+/*@}*/
+
+/** Draw an outline.
+ * @param x The x-coordinate.
+ * @param y The y-coordinate.
+ * @param width The width of the outline.
+ * @param height The height of the outline.
+ */
+void DrawOutline(int x, int y, int width, int height);
+
+/** Clear an outline. */
+void ClearOutline();
+
+#endif
+
diff --git a/src/pager.c b/src/pager.c
new file mode 100644
index 0000000..6c237bd
--- /dev/null
+++ b/src/pager.c
@@ -0,0 +1,331 @@
+/****************************************************************************
+ * Functions for displaying the pager.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "pager.h"
+#include "tray.h"
+#include "main.h"
+#include "desktop.h"
+#include "client.h"
+#include "color.h"
+
+typedef struct PagerType {
+
+	TrayComponentType *cp;
+
+	int deskWidth;
+	int deskHeight;
+	double scalex, scaley;
+	LayoutType layout;
+
+	Pixmap buffer;
+
+	struct PagerType *next;
+
+} PagerType;
+
+static PagerType *pagers;
+
+static void Create(TrayComponentType *cp);
+static void Destroy(TrayComponentType *cp);
+
+static void SetSize(TrayComponentType *cp, int width, int height);
+
+static void ProcessPagerButtonEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+
+static void DrawPagerClient(const PagerType *pp, const ClientNode *np);
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializePager() {
+	pagers = NULL;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupPager() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownPager() {
+
+	PagerType *pp;
+
+	for(pp = pagers; pp; pp = pp->next) {
+		JXFreePixmap(display, pp->buffer);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyPager() {
+
+	PagerType *pp;
+
+	while(pagers) {
+		pp = pagers->next;
+		Release(pagers);
+		pagers = pp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+TrayComponentType *CreatePager() {
+
+	TrayComponentType *cp;
+	PagerType *pp;
+
+	pp = Allocate(sizeof(PagerType));
+	pp->next = pagers;
+	pagers = pp;
+
+	cp = CreateTrayComponent();
+	cp->object = pp;
+	pp->cp = cp;
+	cp->Create = Create;
+	cp->Destroy = Destroy;
+	cp->SetSize = SetSize;
+	cp->ProcessButtonEvent = ProcessPagerButtonEvent;
+
+	return cp;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void Create(TrayComponentType *cp) {
+
+	PagerType *pp;
+
+	Assert(cp);
+
+	pp = (PagerType*)cp->object;
+
+	Assert(pp);
+
+	Assert(cp->width > 0);
+	Assert(cp->height > 0);
+
+	cp->pixmap = JXCreatePixmap(display, rootWindow, cp->width,
+		cp->height, rootDepth);
+	pp->buffer = cp->pixmap;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void Destroy(TrayComponentType *cp) {
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetSize(TrayComponentType *cp, int width, int height) {
+
+	PagerType *pp;
+
+	Assert(cp);
+
+	pp = (PagerType*)cp->object;
+
+	Assert(pp);
+
+	if(width) {
+
+		/* Vertical pager, compute height from width. */
+		cp->width = width;
+		pp->deskWidth = width;
+		pp->deskHeight = (cp->width * rootHeight) / rootWidth;
+		cp->height = (pp->deskHeight + 1) * desktopCount;
+		pp->layout = LAYOUT_VERTICAL;
+
+	} else if(height) {
+
+		/* Horizontal pager, compute width from height. */
+		cp->height = height;
+		pp->deskHeight = height;
+		pp->deskWidth = (cp->height * rootWidth) / rootHeight;
+		cp->width = (pp->deskWidth + 1) * desktopCount;
+		pp->layout = LAYOUT_HORIZONTAL;
+
+	} else {
+		Assert(0);
+	}
+
+	pp->scalex = (double)(pp->deskWidth - 2) / rootWidth;
+	pp->scaley = (double)(pp->deskHeight - 2) / rootHeight;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ProcessPagerButtonEvent(TrayComponentType *cp, int x, int y, int mask) {
+
+	PagerType *pp;
+
+	switch(mask) {
+	case Button1:
+	case Button2:
+	case Button3:
+		pp = (PagerType*)cp->object;
+		if(pp->layout == LAYOUT_HORIZONTAL) {
+			ChangeDesktop(x / (pp->deskWidth + 1));
+		} else {
+			ChangeDesktop(y / (pp->deskHeight + 1));
+		}
+		break;
+	case Button4:
+		PreviousDesktop();
+		break;
+	case Button5:
+		NextDesktop();
+		break;
+	default:
+		break;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void UpdatePager() {
+
+	PagerType *pp;
+	ClientNode *np;
+	Pixmap buffer;
+	int width, height;
+	int deskWidth, deskHeight;
+	unsigned int x;
+
+	if(shouldExit) {
+		return;
+	}
+
+	for(pp = pagers; pp; pp = pp->next) {
+
+		buffer = pp->cp->pixmap;
+		width = pp->cp->width;
+		height = pp->cp->height;
+		deskWidth = pp->deskWidth;
+		deskHeight = pp->deskHeight;
+
+		/* Draw the background. */
+		JXSetForeground(display, rootGC, colors[COLOR_PAGER_BG]);
+		JXFillRectangle(display, buffer, rootGC, 0, 0, width, height);
+
+		/* Highlight the current desktop. */
+		JXSetForeground(display, rootGC, colors[COLOR_PAGER_ACTIVE_BG]);
+		if(pp->layout == LAYOUT_HORIZONTAL) {
+			JXFillRectangle(display, buffer, rootGC,
+				currentDesktop * (deskWidth + 1), 0,
+				deskWidth, height);
+		} else {
+			JXFillRectangle(display, buffer, rootGC,
+				0, currentDesktop * (deskHeight + 1),
+				width, deskHeight);
+		}
+
+		/* Draw the clients. */
+		for(x = LAYER_BOTTOM; x <= LAYER_TOP; x++) {
+			for(np = nodeTail[x]; np; np = np->prev) {
+				DrawPagerClient(pp, np);
+			}
+		}
+
+		/* Draw the desktop dividers. */
+		JXSetForeground(display, rootGC, colors[COLOR_PAGER_FG]);
+		for(x = 1; x < desktopCount; x++) {
+			if(pp->layout == LAYOUT_HORIZONTAL) {
+				JXDrawLine(display, buffer, rootGC,
+					(deskWidth + 1) * x - 1, 0,
+					(deskWidth + 1) * x - 1, height);
+			} else {
+				JXDrawLine(display, buffer, rootGC,
+					0, (deskHeight + 1) * x - 1,
+					width, (deskHeight + 1) * x - 1);
+			}
+		}
+
+		/* Tell the tray to redraw. */
+		UpdateSpecificTray(pp->cp->tray, pp->cp);
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DrawPagerClient(const PagerType *pp, const ClientNode *np) {
+
+	int x, y;
+	int width, height;
+	int deskOffset;
+	ColorType fillColor;
+
+	if(!(np->state.status & STAT_MAPPED)) {
+		return;
+	}
+
+	if(np->state.status & STAT_STICKY) {
+		deskOffset = currentDesktop;
+	} else {
+		deskOffset = np->state.desktop;
+	}
+	if(pp->layout == LAYOUT_HORIZONTAL) {
+		deskOffset *= pp->deskWidth + 1;
+	} else {
+		deskOffset *= pp->deskHeight + 1;
+	}
+
+	x = (int)((double)np->x * pp->scalex + 1.0);
+	y = (int)((double)np->y * pp->scaley + 1.0);
+	width = (int)((double)np->width * pp->scalex);
+	height = (int)((double)np->height * pp->scaley);
+
+	if(x + width > pp->deskWidth) {
+		width = pp->deskWidth - x;
+	}
+	if(y + height > pp->deskHeight) {
+		height = pp->deskHeight - y;
+	}
+	if(x < 0) {
+		width += x;
+		x = 0;
+	}
+	if(y < 0) {
+		height += y;
+		y = 0;
+	}
+	if(width <= 0 || height <= 0) {
+		return;
+	}
+
+	if(pp->layout == LAYOUT_HORIZONTAL) {
+		x += deskOffset;
+	} else {
+		y += deskOffset;
+	}
+
+	JXSetForeground(display, rootGC, colors[COLOR_PAGER_OUTLINE]);
+	JXDrawRectangle(display, pp->cp->pixmap, rootGC, x, y, width, height);
+
+	if(width > 1 && height > 1) {
+		if((np->state.status & STAT_ACTIVE)
+			&& (np->state.desktop == currentDesktop
+			|| (np->state.status & STAT_STICKY))) {
+			fillColor = COLOR_PAGER_ACTIVE_FG;
+		} else {
+			fillColor = COLOR_PAGER_FG;
+		}
+		JXSetForeground(display, rootGC, colors[fillColor]);
+		JXFillRectangle(display, pp->cp->pixmap, rootGC, x + 1, y + 1,
+			width - 1, height - 1);
+	}
+
+}
+
diff --git a/src/pager.h b/src/pager.h
new file mode 100644
index 0000000..a3a8f01
--- /dev/null
+++ b/src/pager.h
@@ -0,0 +1,27 @@
+/**
+ * @file pager.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Pager tray component.
+ *
+ */
+
+#ifndef PAGER_H
+#define PAGER_H
+
+struct TrayComponentType;
+
+/*@{*/
+void InitializePager();
+void StartupPager();
+void ShutdownPager();
+void DestroyPager();
+/*@}*/
+
+struct TrayComponentType *CreatePager();
+
+void UpdatePager();
+
+#endif
+
diff --git a/src/parse.c b/src/parse.c
new file mode 100644
index 0000000..5dd82af
--- /dev/null
+++ b/src/parse.c
@@ -0,0 +1,1551 @@
+/****************************************************************************
+ * Parser for the JWM XML configuration file.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "parse.h"
+#include "lex.h"
+#include "menu.h"
+#include "root.h"
+#include "client.h"
+#include "tray.h"
+#include "group.h"
+#include "desktop.h"
+#include "move.h"
+#include "resize.h"
+#include "misc.h"
+#include "swallow.h"
+#include "pager.h"
+#include "error.h"
+#include "key.h"
+#include "cursor.h"
+#include "main.h"
+#include "font.h"
+#include "color.h"
+#include "icon.h"
+#include "command.h"
+#include "button.h"
+#include "event.h"
+#include "taskbar.h"
+#include "traybutton.h"
+#include "clock.h"
+#include "dock.h"
+#include "popup.h"
+#include "status.h"
+#include "theme.h"
+
+typedef struct KeyMapType {
+	char *name;
+	KeyType key;
+} KeyMapType;
+
+static const KeyMapType KEY_MAP[] = {
+	{ "up",          KEY_UP           },
+	{ "down",        KEY_DOWN         },
+	{ "right",       KEY_RIGHT        },
+	{ "left",        KEY_LEFT         },
+	{ "escape",      KEY_ESC          },
+	{ "select",      KEY_ENTER        },
+	{ "next",        KEY_NEXT         },
+	{ "nextstacked", KEY_NEXT_STACKED },
+	{ "close",       KEY_CLOSE        },
+	{ "minimize",    KEY_MIN          },
+	{ "maximize",    KEY_MAX          },
+	{ "shade",       KEY_SHADE        },
+	{ "move",        KEY_MOVE         },
+	{ "resize",      KEY_RESIZE       },
+	{ "window",      KEY_WIN          },
+	{ "restart",     KEY_RESTART      },
+	{ "exit",        KEY_EXIT         },
+	{ "desktop",     KEY_DESKTOP      },
+	{ "desktop#",    KEY_DESKTOP      },
+	{ NULL,          KEY_NONE         }
+};
+
+static const char *DEFAULT_TITLE = "JWM";
+static const char *LABEL_ATTRIBUTE = "label";
+static const char *ICON_ATTRIBUTE = "icon";
+static const char *CONFIRM_ATTRIBUTE = "confirm";
+static const char *LABELED_ATTRIBUTE = "labeled";
+static const char *ONROOT_ATTRIBUTE = "onroot";
+static const char *LAYER_ATTRIBUTE = "layer";
+static const char *LAYOUT_ATTRIBUTE = "layout";
+static const char *AUTOHIDE_ATTRIBUTE = "autohide";
+static const char *X_ATTRIBUTE = "x";
+static const char *Y_ATTRIBUTE = "y";
+static const char *WIDTH_ATTRIBUTE = "width";
+static const char *HEIGHT_ATTRIBUTE = "height";
+static const char *NAME_ATTRIBUTE = "name";
+static const char *BORDER_ATTRIBUTE = "border";
+static const char *COUNT_ATTRIBUTE = "count";
+static const char *DISTANCE_ATTRIBUTE = "distance";
+static const char *INSERT_ATTRIBUTE = "insert";
+static const char *MAX_WIDTH_ATTRIBUTE = "maxwidth";
+static const char *FORMAT_ATTRIBUTE = "format";
+static const char *VALIGN_ATTRIBUTE = "valign";
+static const char *HALIGN_ATTRIBUTE = "halign";
+static const char *POPUP_ATTRIBUTE = "popup";
+static const char *DELAY_ATTRIBUTE = "delay";
+static const char *ENABLED_ATTRIBUTE = "enabled";
+static const char *COORDINATES_ATTRIBUTE = "coordinates";
+
+static const char *FALSE_VALUE = "false";
+static const char *TRUE_VALUE = "true";
+
+static int ParseFile(const char *fileName, int depth);
+static char *ReadFile(FILE *fd);
+
+/* Misc. */
+static void Parse(const TokenNode *start, int depth);
+static void ParseInclude(const TokenNode *tp, int depth);
+static void ParseDesktops(const TokenNode *tp);
+
+/* Menus. */
+static void ParseRootMenu(const TokenNode *start);
+static MenuItem *ParseMenuItem(const TokenNode *start, Menu *menu,
+	MenuItem *last);
+static MenuItem *ParseMenuInclude(const TokenNode *tp, Menu *menu,
+	MenuItem *last);
+static MenuItem *InsertMenuItem(MenuItem *last);
+
+/* Tray. */
+static void ParseTray(const TokenNode *tp);
+static void ParsePager(const TokenNode *tp, TrayType *tray);
+static void ParseTaskList(const TokenNode *tp, TrayType *tray);
+static void ParseSwallow(const TokenNode *tp, TrayType *tray);
+static void ParseTrayButton(const TokenNode *tp, TrayType *tray);
+static void ParseClock(const TokenNode *tp, TrayType *tray);
+static void ParseDock(const TokenNode *tp, TrayType *tray);
+
+/* Groups. */
+static void ParseGroup(const TokenNode *tp);
+static void ParseGroupOption(const TokenNode *tp,
+	struct GroupType *group, const char *option);
+
+/* Style. */
+static void ParseBorderStyle(const TokenNode *start);
+static void ParseTaskListStyle(const TokenNode *start);
+static void ParseTrayStyle(const TokenNode *start);
+static void ParsePagerStyle(const TokenNode *start);
+static void ParseMenuStyle(const TokenNode *start);
+static void ParsePopupStyle(const TokenNode *start);
+static void ParseClockStyle(const TokenNode *start);
+static void ParseTrayButtonStyle(const TokenNode *start);
+
+/* Feel. */
+static void ParseKey(const TokenNode *tp);
+static void ParseMouse(const TokenNode *tp);
+static void ParseSnapMode(const TokenNode *tp);
+static void ParseMoveMode(const TokenNode *tp);
+static void ParseResizeMode(const TokenNode *tp);
+static void ParseFocusModel(const TokenNode *tp);
+
+static char *FindAttribute(AttributeNode *ap, const char *name);
+static void ReleaseTokens(TokenNode *np);
+static void InvalidTag(const TokenNode *tp, TokenType parent);
+static void ParseError(const TokenNode *tp, const char *str, ...);
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseConfig(const char *fileName) {
+	if(!ParseFile(fileName, 0)) {
+		if(!ParseFile(SYSTEM_CONFIG, 0)) {
+			ParseError(NULL, "could not open %s or %s", fileName, SYSTEM_CONFIG);
+		}
+	}
+	ValidateTrayButtons();
+	ValidateKeys();
+}
+
+/****************************************************************************
+ * Parse a specific file.
+ * Returns 1 on success and 0 on failure.
+ ****************************************************************************/
+int ParseFile(const char *fileName, int depth) {
+
+	TokenNode *tokens;
+	FILE *fd;
+	char *buffer;
+
+	++depth;
+	if(depth > MAX_INCLUDE_DEPTH) {
+		ParseError(NULL, "include depth (%d) exceeded", MAX_INCLUDE_DEPTH);
+		return 0;
+	}
+
+	fd = fopen(fileName, "r");
+	if(!fd) {
+		return 0;
+	}
+
+	buffer = ReadFile(fd);
+	fclose(fd);
+
+	tokens = Tokenize(buffer, fileName);
+	Release(buffer);
+	Parse(tokens, depth);
+	ReleaseTokens(tokens);
+
+	return 1;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ReleaseTokens(TokenNode *np) {
+
+	AttributeNode *ap;
+	TokenNode *tp;
+
+	while(np) {
+		tp = np->next;
+
+		while(np->attributes) {
+			ap = np->attributes->next;
+			if(np->attributes->name) {
+				Release(np->attributes->name);
+			}
+			if(np->attributes->value) {
+				Release(np->attributes->value);
+			}
+			Release(np->attributes);
+			np->attributes = ap;
+		}
+
+		if(np->subnodeHead) {
+			ReleaseTokens(np->subnodeHead);
+		}
+
+		if(np->value) {
+			Release(np->value);
+		}
+
+		if(np->invalidName) {
+			Release(np->invalidName);
+		}
+
+		if(np->fileName) {
+			Release(np->fileName);
+		}
+
+		Release(np);
+		np = tp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Parse(const TokenNode *start, int depth) {
+
+	TokenNode *tp;
+
+	if(!start) {
+		return;
+	}
+
+	if(start->type == TOK_JWM) {
+		for(tp = start->subnodeHead; tp; tp = tp->next) {
+			switch(tp->type) {
+			case TOK_BORDERSTYLE:
+				ParseBorderStyle(tp);
+				break;
+			case TOK_DESKTOPS:
+				ParseDesktops(tp);
+				break;
+			case TOK_DOUBLECLICKSPEED:
+				SetDoubleClickSpeed(tp->value);
+				break;
+			case TOK_DOUBLECLICKDELTA:
+				SetDoubleClickDelta(tp->value);
+				break;
+			case TOK_FOCUSMODEL:
+				ParseFocusModel(tp);
+				break;
+			case TOK_GROUP:
+				ParseGroup(tp);
+				break;
+			case TOK_ICONPATH:
+				AddIconPath(tp->value);
+				break;
+			case TOK_INCLUDE:
+				ParseInclude(tp, depth);
+				break;
+			case TOK_KEY:
+				ParseKey(tp);
+				break;
+			case TOK_MENUSTYLE:
+				ParseMenuStyle(tp);
+				break;
+			case TOK_MOUSE:
+				ParseMouse(tp);
+				break;
+			case TOK_MOVEMODE:
+				ParseMoveMode(tp);
+				break;
+			case TOK_PAGERSTYLE:
+				ParsePagerStyle(tp);
+				break;
+			case TOK_POPUPSTYLE:
+				ParsePopupStyle(tp);
+				break;
+			case TOK_RESIZEMODE:
+				ParseResizeMode(tp);
+				break;
+			case TOK_RESTARTCOMMAND:
+				AddRestartCommand(tp->value);
+				break;
+			case TOK_ROOTMENU:
+				ParseRootMenu(tp);
+				break;
+			case TOK_SHUTDOWNCOMMAND:
+				AddShutdownCommand(tp->value);
+				break;
+			case TOK_SNAPMODE:
+				ParseSnapMode(tp);
+				break;
+			case TOK_STARTUPCOMMAND:
+				AddStartupCommand(tp->value);
+				break;
+			case TOK_TASKLISTSTYLE:
+				ParseTaskListStyle(tp);
+				break;
+			case TOK_TRAY:
+				ParseTray(tp);
+				break;
+			case TOK_TRAYSTYLE:
+				ParseTrayStyle(tp);
+				break;
+			case TOK_TRAYBUTTONSTYLE:
+				ParseTrayButtonStyle(tp);
+				break;
+			case TOK_CLOCKSTYLE:
+				ParseClockStyle(tp);
+				break;
+			case TOK_THEMEPATH:
+				AddThemePath(tp->value);
+				break;
+			case TOK_THEME:
+				SetTheme(tp->value);
+				break;
+			default:
+				InvalidTag(tp, TOK_JWM);
+				break;
+			}
+		}
+	} else {
+		ParseError(start, "invalid start tag: %s", GetTokenName(start));
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseFocusModel(const TokenNode *tp) {
+	if(tp->value) {
+		if(!strcmp(tp->value, "sloppy")) {
+			focusModel = FOCUS_SLOPPY;
+		} else if(!strcmp(tp->value, "click")) {
+			focusModel = FOCUS_CLICK;
+		} else {
+			ParseError(tp, "invalid focus model: \"%s\"", tp->value);
+		}
+	} else {
+		ParseError(tp, "focus model not specified");
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseSnapMode(const TokenNode *tp) {
+
+	const char *distance;
+
+	distance = FindAttribute(tp->attributes, DISTANCE_ATTRIBUTE);
+	if(distance) {
+		SetSnapDistance(distance);
+	} else {
+		SetDefaultSnapDistance();
+	}
+
+	if(tp->value) {
+		if(!strcmp(tp->value, "none")) {
+			SetSnapMode(SNAP_NONE);
+		} else if(!strcmp(tp->value, "screen")) {
+			SetSnapMode(SNAP_SCREEN);
+		} else if(!strcmp(tp->value, "border")) {
+			SetSnapMode(SNAP_BORDER);
+		} else {
+			ParseError(tp, "invalid snap mode: %s", tp->value);
+		}
+	} else {
+		ParseError(tp, "snap mode not specified");
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseMoveMode(const TokenNode *tp) {
+
+	const char *str;
+
+	str = FindAttribute(tp->attributes, COORDINATES_ATTRIBUTE);
+	SetMoveStatusType(str);
+
+	if(tp->value) {
+		if(!strcmp(tp->value, "outline")) {
+			SetMoveMode(MOVE_OUTLINE);
+		} else if(!strcmp(tp->value, "opaque")) {
+			SetMoveMode(MOVE_OPAQUE);
+		} else {
+			ParseError(tp, "invalid move mode: %s", tp->value);
+		}
+	} else {
+		ParseError(tp, "move mode not specified");
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseResizeMode(const TokenNode *tp) {
+
+	const char *str;
+
+	str = FindAttribute(tp->attributes, COORDINATES_ATTRIBUTE);
+	SetResizeStatusType(str);
+
+	if(tp->value) {
+		if(!strcmp(tp->value, "outline")) {
+			SetResizeMode(RESIZE_OUTLINE);
+		} else if(!strcmp(tp->value, "opaque")) {
+			SetResizeMode(RESIZE_OPAQUE);
+		} else {
+			ParseError(tp, "invalid resize mode: %s", tp->value);
+		}
+	} else {
+		ParseError(tp, "resize mode not specified");
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseRootMenu(const TokenNode *start) {
+
+	const char *value;
+	Menu *menu;
+
+	menu = Allocate(sizeof(Menu));
+
+	value = FindAttribute(start->attributes, HEIGHT_ATTRIBUTE);
+	if(value) {
+		menu->itemHeight = atoi(value);
+	} else {
+		menu->itemHeight = 0;
+	}
+
+	value = FindAttribute(start->attributes, LABELED_ATTRIBUTE);
+	if(value && !strcmp(value, TRUE_VALUE)) {
+		value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
+		if(!value) {
+			value = DEFAULT_TITLE;
+		}
+		menu->label = CopyString(value);
+	} else {
+		menu->label = NULL;
+	}
+
+	menu->items = NULL;
+	ParseMenuItem(start->subnodeHead, menu, NULL);
+
+	value = FindAttribute(start->attributes, ONROOT_ATTRIBUTE);
+	if(!value) {
+		value = "123";
+	}
+
+	SetRootMenu(value, menu);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+MenuItem *InsertMenuItem(MenuItem *last) {
+
+	MenuItem *item;
+
+	item = Allocate(sizeof(MenuItem));
+	item->name = NULL;
+	item->type = MENU_ITEM_NORMAL;
+	item->iconName = NULL;
+	item->action.type = MA_NONE;
+	item->action.data.str = NULL;
+	item->submenu = NULL;
+
+	item->next = NULL;
+	if(last) {
+		last->next = item;
+	}
+
+	return item;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+MenuItem *ParseMenuItem(const TokenNode *start, Menu *menu,
+	MenuItem *last) {
+
+	Menu *child;
+	const char *value;
+
+	Assert(menu);
+
+	menu->offsets = NULL;
+	while(start) {
+		switch(start->type) {
+		case TOK_INCLUDE:
+
+			last = ParseMenuInclude(start, menu, last);
+
+			break;
+		case TOK_MENU:
+
+			last = InsertMenuItem(last);
+			last->type = MENU_ITEM_SUBMENU;
+			if(!menu->items) {
+				menu->items = last;
+			}
+
+			value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
+			last->name = CopyString(value);
+
+			value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
+			last->iconName = CopyString(value);
+
+			last->submenu = Allocate(sizeof(Menu));
+			child = last->submenu;
+
+			value = FindAttribute(start->attributes, HEIGHT_ATTRIBUTE);
+			if(value) {
+				child->itemHeight = atoi(value);
+			} else {
+				child->itemHeight = menu->itemHeight;
+			}
+
+			value = FindAttribute(start->attributes, LABELED_ATTRIBUTE);
+			if(value && !strcmp(value, TRUE_VALUE)) {
+				if(last->name) {
+					child->label = CopyString(last->name);
+				} else {
+					child->label = CopyString(DEFAULT_TITLE);
+				}
+			} else {
+				child->label = NULL;
+			}
+
+			last->submenu->items = NULL;
+			ParseMenuItem(start->subnodeHead, last->submenu, NULL);
+
+			break;
+		case TOK_PROGRAM:
+
+			last = InsertMenuItem(last);
+			if(!menu->items) {
+				menu->items = last;
+			}
+
+			value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
+			if(value) {
+				last->name = CopyString(value);
+			} else if(start->value) {
+				last->name = CopyString(start->value);
+			}
+
+			value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
+			last->iconName = CopyString(value);
+
+			last->action.type = MA_EXECUTE;
+			last->action.data.str = CopyString(start->value);
+
+			break;
+		case TOK_SEPARATOR:
+
+			last = InsertMenuItem(last);
+			last->type = MENU_ITEM_SEPARATOR;
+			if(!menu->items) {
+				menu->items = last;
+			}
+
+			break;
+		case TOK_DESKTOPS:
+		case TOK_STICK:
+		case TOK_MAXIMIZE:
+		case TOK_MINIMIZE:
+		case TOK_SHADE:
+		case TOK_MOVE:
+		case TOK_RESIZE:
+		case TOK_KILL:
+		case TOK_CLOSE:
+
+			last = InsertMenuItem(last);
+			if(!menu->items) {
+				menu->items = last;
+			}
+
+			value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
+			if(!value) {
+				value = GetTokenName(start);
+			}
+			last->name = CopyString(value);
+
+			value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
+			last->iconName = CopyString(value);
+
+			switch(start->type) {
+			case TOK_DESKTOPS:
+				last->action.type = MA_DESKTOP;
+				break;
+			case TOK_STICK:
+				last->action.type = MA_STICK;
+				break;
+			case TOK_MAXIMIZE:
+				last->action.type = MA_MAXIMIZE;
+				break;
+			case TOK_MINIMIZE:
+				last->action.type = MA_MINIMIZE;
+				break;
+			case TOK_SHADE:
+				last->action.type = MA_SHADE;
+				break;
+			case TOK_MOVE:
+				last->action.type = MA_MOVE;
+				break;
+			case TOK_RESIZE:
+				last->action.type = MA_RESIZE;
+				break;
+			case TOK_KILL:
+				last->action.type = MA_KILL;
+				break;
+			case TOK_CLOSE:
+				last->action.type = MA_CLOSE;
+				break;
+			default:
+				break;
+			}
+
+			break;
+		case TOK_EXIT:
+
+			last = InsertMenuItem(last);
+			if(!menu->items) {
+				menu->items = last;
+			}
+
+			value = FindAttribute(start->attributes, CONFIRM_ATTRIBUTE);
+			if(value && !strcmp(value, FALSE_VALUE)) {
+				SetShowExitConfirmation(0);
+			} else {
+				SetShowExitConfirmation(1);
+			}
+
+			value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
+			if(!value) {
+				value = GetTokenName(start);
+			}
+			last->name = CopyString(value);
+
+			value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
+			last->iconName = CopyString(value);
+
+			last->action.type = MA_EXIT;
+			last->action.data.str = CopyString(start->value);
+
+			break;
+		case TOK_RESTART:
+
+			last = InsertMenuItem(last);
+			if(!menu->items) {
+				menu->items = last;
+			}
+
+			value = FindAttribute(start->attributes, LABEL_ATTRIBUTE);
+			if(!value) {
+				value = GetTokenName(start);
+			}
+			last->name = CopyString(value);
+
+			value = FindAttribute(start->attributes, ICON_ATTRIBUTE);
+			last->iconName = CopyString(value);
+
+			last->action.type = MA_RESTART;
+
+			break;
+		default:
+			InvalidTag(start, TOK_MENU);
+			break;
+		}
+		start = start->next;
+	}
+
+	return last;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+MenuItem *ParseMenuInclude(const TokenNode *tp, Menu *menu,
+	MenuItem *last) {
+
+	FILE *fd;
+	char *path;
+	char *buffer = NULL;
+	TokenNode *mp;
+
+	Assert(tp);
+
+	if(!strncmp(tp->value, "exec:", 5)) {
+
+		path = Allocate(strlen(tp->value) - 5 + 1);
+		strcpy(path, tp->value + 5);
+		ExpandPath(&path);
+
+		fd = popen(path, "r");
+		if(fd) {
+			buffer = ReadFile(fd);
+			pclose(fd);
+		} else {
+			ParseError(tp, "could not execute included program: %s", path);
+		}
+
+	} else {
+
+		path = CopyString(tp->value);
+		ExpandPath(&path);
+
+		fd = fopen(path, "r");
+		if(fd) {
+			buffer = ReadFile(fd);
+			fclose(fd);
+		} else {
+			ParseError(tp, "could not open include: %s", path);
+		}
+
+	}
+
+	if(!buffer) {
+		Release(path);
+		return last;
+	}
+
+	mp = Tokenize(buffer, path);
+	Release(buffer);
+	Release(path);
+
+	if(!mp || mp->type != TOK_MENU) {
+		ParseError(tp, "invalid included menu: %s", tp->value);
+	} else {
+		last = ParseMenuItem(mp, menu, last);
+	}
+
+	if(mp) {
+		ReleaseTokens(mp);
+	}
+
+	return last;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseKey(const TokenNode *tp) {
+
+	const char *key;
+	const char *code;
+	const char *mask;
+	const char *action;
+	const char *command;
+	KeyType k;
+	int x;
+
+	Assert(tp);
+
+	mask = FindAttribute(tp->attributes, "mask");
+	key = FindAttribute(tp->attributes, "key");
+	code = FindAttribute(tp->attributes, "keycode");
+
+	action = tp->value;
+	if(action == NULL) {
+		ParseError(tp, "no action specified for Key");
+		return;
+	}
+
+	command = NULL;
+	k = KEY_NONE;
+	if(!strncmp(action, "exec:", 5)) {
+		k = KEY_EXEC;
+		command = action + 5;
+	} else if(!strncmp(action, "root:", 5)) {
+		k = KEY_ROOT;
+		command = action + 5;
+	} else {
+		for(x = 0; KEY_MAP[x].name; x++) {
+			if(!strcmp(action, KEY_MAP[x].name)) {
+				k = KEY_MAP[x].key;
+				break;
+			}
+		}
+	}
+
+	if(k == KEY_NONE) {
+		ParseError(tp, "invalid Key action: \"%s\"", action);
+	} else {
+		InsertBinding(k, mask, key, code, command);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseMouse(const TokenNode *tp) {
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseBorderStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+
+	Assert(tp);
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_BORDER, np->value);
+			break;
+		case TOK_WIDTH:
+			SetBorderWidth(np->value);
+			break;
+		case TOK_HEIGHT:
+			SetTitleHeight(np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_BORDER_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_BORDER_BG, np->value);
+			break;
+		case TOK_ACTIVEFOREGROUND:
+			SetColor(COLOR_BORDER_ACTIVE_FG, np->value);
+			break;
+		case TOK_ACTIVEBACKGROUND:
+			SetColor(COLOR_BORDER_ACTIVE_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_BORDERSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseInclude(const TokenNode *tp, int depth) {
+
+	char *temp;
+
+	Assert(tp);
+
+	if(!tp->value) {
+
+		ParseError(tp, "no include file specified", temp);
+
+	} else {
+
+		temp = CopyString(tp->value);
+
+		ExpandPath(&temp);
+
+		if(!ParseFile(temp, depth)) {
+			ParseError(tp, "could not open included file %s", temp);
+		}
+
+		Release(temp);
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseDesktops(const TokenNode *tp) {
+
+	TokenNode *np;
+	char *attr;
+	unsigned int x;
+
+	Assert(tp);
+
+	attr = FindAttribute(tp->attributes, COUNT_ATTRIBUTE);
+	if(attr) {
+		SetDesktopCount(attr);
+	}	else {
+		desktopCount = DEFAULT_DESKTOP_COUNT;
+	}
+
+	x = 0;
+	for(x = 0, np = tp->subnodeHead; np; np = np->next, x++) {
+		if(x >= desktopCount) {
+			break;
+		}
+		switch(np->type) {
+		case TOK_NAME:
+			SetDesktopName(x, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_DESKTOPS);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseTaskListStyle(const TokenNode *tp) {
+
+	const char *temp;
+	TokenNode *np;
+
+	temp = FindAttribute(tp->attributes, INSERT_ATTRIBUTE);
+	if(temp) {
+		SetTaskBarInsertMode(temp);
+	}
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_TASK, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_TASK_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_TASK_BG, np->value);
+			break;
+		case TOK_ACTIVEFOREGROUND:
+			SetColor(COLOR_TASK_ACTIVE_FG, np->value);
+			break;
+		case TOK_ACTIVEBACKGROUND:
+			SetColor(COLOR_TASK_ACTIVE_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_TASKLISTSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseTrayStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_TRAY, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_TRAY_BG, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_TRAY_FG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_TRAYSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseTray(const TokenNode *tp) {
+
+	const TokenNode *np;
+	const char *attr;
+	TrayType *tray;
+
+	Assert(tp);
+
+	tray = CreateTray();
+
+	attr = FindAttribute(tp->attributes, AUTOHIDE_ATTRIBUTE);
+	if(attr && !strcmp(attr, TRUE_VALUE)) {
+		SetAutoHideTray(tray, 1);
+	} else {
+		SetAutoHideTray(tray, 0);
+	}
+
+	attr = FindAttribute(tp->attributes, X_ATTRIBUTE);
+	if(attr) {
+		SetTrayX(tray, attr);
+	}
+
+	attr = FindAttribute(tp->attributes, Y_ATTRIBUTE);
+	if(attr) {
+		SetTrayY(tray, attr);
+	}
+
+	attr = FindAttribute(tp->attributes, WIDTH_ATTRIBUTE);
+	if(attr) {
+		SetTrayWidth(tray, attr);
+	}
+
+	attr = FindAttribute(tp->attributes, HEIGHT_ATTRIBUTE);
+	if(attr) {
+		SetTrayHeight(tray, attr);
+	}
+
+	attr = FindAttribute(tp->attributes, VALIGN_ATTRIBUTE);
+	SetTrayVerticalAlignment(tray, attr);
+
+	attr = FindAttribute(tp->attributes, HALIGN_ATTRIBUTE);
+	SetTrayHorizontalAlignment(tray, attr);
+
+	attr = FindAttribute(tp->attributes, LAYOUT_ATTRIBUTE);
+	SetTrayLayout(tray, attr);
+
+	attr = FindAttribute(tp->attributes, LAYER_ATTRIBUTE);
+	if(attr) {
+		SetTrayLayer(tray, attr);
+	}
+
+	attr = FindAttribute(tp->attributes, BORDER_ATTRIBUTE);
+	if(attr) {
+		SetTrayBorder(tray, attr);
+	}
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_PAGER:
+			ParsePager(np, tray);
+			break;
+		case TOK_TASKLIST:
+			ParseTaskList(np, tray);
+			break;
+		case TOK_SWALLOW:
+			ParseSwallow(np, tray);
+			break;
+		case TOK_TRAYBUTTON:
+			ParseTrayButton(np, tray);
+			break;
+		case TOK_CLOCK:
+			ParseClock(np, tray);
+			break;
+		case TOK_DOCK:
+			ParseDock(np, tray);
+			break;
+		default:
+			InvalidTag(np, TOK_TRAY);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParsePager(const TokenNode *tp, TrayType *tray) {
+
+	TrayComponentType *cp;
+
+	Assert(tp);
+	Assert(tray);
+
+	cp = CreatePager();
+	AddTrayComponent(tray, cp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseTaskList(const TokenNode *tp, TrayType *tray) {
+
+	TrayComponentType *cp;
+	const char *temp;
+
+	Assert(tp);
+	Assert(tray);
+
+	cp = CreateTaskBar();
+	AddTrayComponent(tray, cp);
+
+	temp = FindAttribute(tp->attributes, MAX_WIDTH_ATTRIBUTE);
+	if(temp) {
+		SetMaxTaskBarItemWidth(cp, temp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseSwallow(const TokenNode *tp, TrayType *tray) {
+
+	TrayComponentType *cp;
+	const char *name;
+	const char *temp;
+	int width, height;
+
+	Assert(tp);
+	Assert(tray);
+
+	name = FindAttribute(tp->attributes, NAME_ATTRIBUTE);
+	if(name == NULL) {
+		name = tp->value;
+	}
+
+	temp = FindAttribute(tp->attributes, WIDTH_ATTRIBUTE);
+	if(temp) {
+		width = atoi(temp);
+	} else {
+		width = 0;
+	}
+
+	temp = FindAttribute(tp->attributes, HEIGHT_ATTRIBUTE);
+	if(temp) {
+		height = atoi(temp);
+	} else {
+		height = 0;
+	}
+
+	cp = CreateSwallow(name, tp->value, width, height);
+	if(cp) {
+		AddTrayComponent(tray, cp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseTrayButton(const TokenNode *tp, TrayType *tray) {
+
+	TrayComponentType *cp;
+	const char *icon;
+	const char *label;
+	const char *popup;
+	const char *temp;
+	int width, height;
+
+	Assert(tp);
+	Assert(tray);
+
+	icon = FindAttribute(tp->attributes, ICON_ATTRIBUTE);
+	label = FindAttribute(tp->attributes, LABEL_ATTRIBUTE);
+	popup = FindAttribute(tp->attributes, POPUP_ATTRIBUTE);
+
+	temp = FindAttribute(tp->attributes, WIDTH_ATTRIBUTE);
+	if(temp) {
+		width = atoi(temp);
+	} else {
+		width = 0;
+	}
+
+	temp = FindAttribute(tp->attributes, HEIGHT_ATTRIBUTE);
+	if(temp) {
+		height = atoi(temp);
+	} else {
+		height = 0;
+	}
+
+	cp = CreateTrayButton(icon, label, tp->value, popup, width, height);
+	if(cp) {
+		AddTrayComponent(tray, cp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseClock(const TokenNode *tp, TrayType *tray) {
+
+	TrayComponentType *cp;
+	const char *format;
+	const char *command;
+	const char *temp;
+	int width, height;
+
+	Assert(tp);
+	Assert(tray);
+
+	format = FindAttribute(tp->attributes, FORMAT_ATTRIBUTE);
+
+	if(tp->value && strlen(tp->value) > 0) {
+		command = tp->value;
+	} else {
+		command = NULL;
+	}
+
+	temp = FindAttribute(tp->attributes, WIDTH_ATTRIBUTE);
+	if(temp) {
+		width = atoi(temp);
+	} else {
+		width = 0;
+	}
+
+	temp = FindAttribute(tp->attributes, HEIGHT_ATTRIBUTE);
+	if(temp) {
+		height = atoi(temp);
+	} else {
+		height = 0;
+	}
+
+	cp = CreateClock(format, command, width, height);
+	if(cp) {
+		AddTrayComponent(tray, cp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseDock(const TokenNode *tp, TrayType *tray) {
+
+	TrayComponentType *cp;
+
+	Assert(tp);
+	Assert(tray);
+
+	cp = CreateDock();
+	if(cp) {
+		AddTrayComponent(tray, cp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParsePagerStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+
+	Assert(tp);
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_OUTLINE:
+			SetColor(COLOR_PAGER_OUTLINE, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_PAGER_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_PAGER_BG, np->value);
+			break;
+		case TOK_ACTIVEFOREGROUND:
+			SetColor(COLOR_PAGER_ACTIVE_FG, np->value);
+			break;
+		case TOK_ACTIVEBACKGROUND:
+			SetColor(COLOR_PAGER_ACTIVE_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_PAGERSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParsePopupStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+	const char *str;
+
+	Assert(tp);
+
+	str = FindAttribute(tp->attributes, ENABLED_ATTRIBUTE);
+	if(str) {
+		if(!strcmp(str, TRUE_VALUE)) {
+			SetPopupEnabled(1);
+		} else if(!strcmp(str, FALSE_VALUE)) {
+			SetPopupEnabled(0);
+		} else {
+			ParseError(tp, "invalid enabled value: \"%s\"", str);
+		}
+	}
+
+	str = FindAttribute(tp->attributes, DELAY_ATTRIBUTE);
+	if(str) {
+		SetPopupDelay(str);
+	}
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_POPUP, np->value);
+			break;
+		case TOK_OUTLINE:
+			SetColor(COLOR_POPUP_OUTLINE, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_POPUP_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_POPUP_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_POPUPSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseMenuStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+
+	Assert(tp);
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_MENU, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_MENU_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_MENU_BG, np->value);
+			break;
+		case TOK_ACTIVEFOREGROUND:
+			SetColor(COLOR_MENU_ACTIVE_FG, np->value);
+			break;
+		case TOK_ACTIVEBACKGROUND:
+			SetColor(COLOR_MENU_ACTIVE_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_MENUSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseClockStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+
+	Assert(tp);
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_CLOCK, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_CLOCK_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_CLOCK_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_CLOCKSTYLE);
+			break;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseTrayButtonStyle(const TokenNode *tp) {
+
+	const TokenNode *np;
+
+	Assert(tp);
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_FONT:
+			SetFont(FONT_TRAYBUTTON, np->value);
+			break;
+		case TOK_FOREGROUND:
+			SetColor(COLOR_TRAYBUTTON_FG, np->value);
+			break;
+		case TOK_BACKGROUND:
+			SetColor(COLOR_TRAYBUTTON_BG, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_TRAYBUTTONSTYLE);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseGroup(const TokenNode *tp) {
+
+	const TokenNode *np;
+	struct GroupType *group;
+
+	Assert(tp);
+
+	group = CreateGroup();
+
+	for(np = tp->subnodeHead; np; np = np->next) {
+		switch(np->type) {
+		case TOK_CLASS:
+			AddGroupClass(group, np->value);
+			break;
+		case TOK_NAME:
+			AddGroupName(group, np->value);
+			break;
+		case TOK_OPTION:
+			ParseGroupOption(np, group, np->value);
+			break;
+		default:
+			InvalidTag(np, TOK_GROUP);
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ParseGroupOption(const TokenNode *tp, struct GroupType *group,
+	const char *option) {
+
+	if(!option) {
+		return;
+	}
+
+	if(!strcmp(option, "sticky")) {
+		AddGroupOption(group, OPTION_STICKY);
+	} else if(!strcmp(option, "nolist")) {
+		AddGroupOption(group, OPTION_NOLIST);
+	} else if(!strcmp(option, "border")) {
+		AddGroupOption(group, OPTION_BORDER);
+	} else if(!strcmp(option, "noborder")) {
+		AddGroupOption(group, OPTION_NOBORDER);
+	} else if(!strcmp(option, "title")) {
+		AddGroupOption(group, OPTION_TITLE);
+	} else if(!strcmp(option, "notitle")) {
+		AddGroupOption(group, OPTION_NOTITLE);
+	} else if(!strcmp(option, "pignore")) {
+		AddGroupOption(group, OPTION_PIGNORE);
+	} else if(!strcmp(option, "maximized")) {
+		AddGroupOption(group, OPTION_MAXIMIZED);
+	} else if(!strcmp(option, "minimized")) {
+		AddGroupOption(group, OPTION_MINIMIZED);
+	} else if(!strcmp(option, "shaded")) {
+		AddGroupOption(group, OPTION_SHADED);
+	} else if(!strncmp(option, "layer:", 6)) {
+		AddGroupOptionValue(group, OPTION_LAYER, option + 6);
+	} else if(!strncmp(option, "desktop:", 8)) {
+		AddGroupOptionValue(group, OPTION_DESKTOP, option + 8);
+	} else if(!strncmp(option, "icon:", 5)) {
+		AddGroupOptionValue(group, OPTION_ICON, option + 5);
+	} else {
+		ParseError(tp, "invalid Group Option: %s", option);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+char *FindAttribute(AttributeNode *ap, const char *name) {
+
+	while(ap) {
+		if(!strcmp(name, ap->name)) {
+			return ap->value;
+		}
+		ap = ap->next;
+	}
+
+	return NULL;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+char *ReadFile(FILE *fd) {
+
+	const int BLOCK_SIZE = 1024;
+
+	char *buffer;
+	int len, max;
+	int ch;
+
+	len = 0;
+	max = BLOCK_SIZE;
+	buffer = Allocate(max + 1);
+
+	for(;;) {
+		ch = fgetc(fd);
+		if(ch == EOF) {
+			break;
+		}
+		buffer[len++] = ch;
+		if(len >= max) {
+			max += BLOCK_SIZE;
+			buffer = Reallocate(buffer, max + 1);
+		}
+	}
+	buffer[len] = 0;
+
+	return buffer;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void InvalidTag(const TokenNode *tp, TokenType parent) {
+
+	ParseError(tp, "invalid tag in %s: %s",
+		GetTokenTypeName(parent), GetTokenName(tp));
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ParseError(const TokenNode *tp, const char *str, ...) {
+
+	va_list ap;
+
+	static const char *NULL_MESSAGE = "configuration error";
+	static const char *FILE_MESSAGE = "%s[%d]";
+
+	char *msg;
+
+	va_start(ap, str);
+
+	if(tp) {
+		msg = Allocate(strlen(FILE_MESSAGE) + strlen(tp->fileName) + 1);
+		sprintf(msg, FILE_MESSAGE, tp->fileName, tp->line);
+	} else {
+		msg = CopyString(NULL_MESSAGE);
+	}
+
+	WarningVA(msg, str, ap);
+
+	Release(msg);
+
+	va_end(ap);
+
+}
+
+
diff --git a/src/parse.h b/src/parse.h
new file mode 100644
index 0000000..4e60f13
--- /dev/null
+++ b/src/parse.h
@@ -0,0 +1,19 @@
+/**
+ * @file parse.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header file for the JWM configuration parser.
+ *
+ */
+
+#ifndef PARSE_H
+#define PARSE_H
+
+/** Parse a configuration file.
+ * @param fileName The file to parse.
+ */
+void ParseConfig(const char *fileName);
+
+#endif
+
diff --git a/src/place.c b/src/place.c
new file mode 100644
index 0000000..f70ce73
--- /dev/null
+++ b/src/place.c
@@ -0,0 +1,647 @@
+/****************************************************************************
+ * Client placement functions.
+ * Copyright (C) 2005 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "place.h"
+#include "client.h"
+#include "screen.h"
+#include "border.h"
+#include "tray.h"
+#include "main.h"
+
+typedef struct BoundingBox {
+	int x, y;
+	int width, height;
+} BoundingBox;
+
+typedef struct Strut {
+	ClientNode *client;
+	BoundingBox box;
+	struct Strut *prev;
+	struct Strut *next;
+} Strut;
+
+static Strut *struts = NULL;
+static Strut *strutsTail = NULL;
+
+/* desktopCount x screenCount */
+/* Note that we assume x and y are 0 based for all screens here. */
+static int *cascadeOffsets = NULL;
+
+static void GetScreenBounds(const ScreenType *sp, BoundingBox *box);
+static void UpdateTrayBounds(BoundingBox *box, unsigned int layer);
+static void UpdateStrutBounds(BoundingBox *box);
+static void SubtractBounds(const BoundingBox *src, BoundingBox *dest);
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializePlacement() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupPlacement() {
+
+	int count;
+	int x;
+
+	count = desktopCount * GetScreenCount();
+	cascadeOffsets = Allocate(count * sizeof(int));
+
+	for(x = 0; x < count; x++) {
+		cascadeOffsets[x] = borderWidth + titleHeight;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownPlacement() {
+
+	Strut *sp;
+
+	Release(cascadeOffsets);
+
+	while(struts) {
+		sp = struts->next;
+		Release(struts);
+		struts = sp;
+	}
+	strutsTail = NULL;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyPlacement() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void RemoveClientStrut(ClientNode *np) {
+
+	Strut *sp;
+
+	for(sp = struts; sp; sp = sp->next) {
+		if(sp->client == np) {
+			if(sp->prev) {
+				sp->prev->next = sp->next;
+			} else {
+				struts = sp->next;
+			}
+			if(sp->next) {
+				sp->next->prev = sp->prev;
+			} else {
+				strutsTail = sp->prev;
+			}
+			Release(sp);
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ReadClientStrut(ClientNode *np) {
+
+	BoundingBox box;
+	Strut *sp;
+	int status;
+	Atom actualType;
+	int actualFormat;
+	unsigned long count;
+	unsigned long bytesLeft;
+	unsigned char *value;
+	long *lvalue;
+	long leftWidth, rightWidth, topHeight, bottomHeight;
+	long leftStart, leftEnd, rightStart, rightEnd;
+	long topStart, topEnd, bottomStart, bottomEnd;
+
+	RemoveClientStrut(np);
+
+	box.x = 0;
+	box.y = 0;
+	box.width = 0;
+	box.height = 0;
+
+	/* First try to read _NET_WM_STRUT_PARTIAL */
+	/* Format is:
+	 *   left_width, right_width, top_width, bottom_width,
+	 *   left_start_y, left_end_y, right_start_y, right_end_y,
+	 *   top_start_x, top_end_x, bottom_start_x, bottom_end_x
+	 */
+	status = JXGetWindowProperty(display, np->window,
+		atoms[ATOM_NET_WM_STRUT_PARTIAL], 0, 12, False, XA_CARDINAL,
+		&actualType, &actualFormat, &count, &bytesLeft, &value);
+	if(status == Success) {
+		if(count == 12) {
+			lvalue = (long*)value;
+			leftWidth = lvalue[0];
+			rightWidth = lvalue[1];
+			topHeight = lvalue[2];
+			bottomHeight = lvalue[3];
+			leftStart = lvalue[4];
+			leftEnd = lvalue[5];
+			rightStart = lvalue[6];
+			rightEnd = lvalue[7];
+			topStart = lvalue[8];
+			topEnd = lvalue[9];
+			bottomStart = lvalue[10];
+			bottomEnd = lvalue[11];
+
+			if(leftWidth > 0) {
+				box.width = leftWidth;
+				box.x = leftStart;
+			}
+
+			if(rightWidth > 0) {
+				box.width = rightWidth;
+				box.x = rightStart;
+			}
+
+			if(topHeight > 0) {
+				box.height = topHeight;
+				box.y = topStart;
+			}
+
+			if(bottomHeight > 0) {
+				box.height = bottomHeight;
+				box.y = bottomStart;
+			}
+
+			sp = Allocate(sizeof(Strut));
+			sp->client = np;
+			sp->box = box;
+			sp->prev = NULL;
+			sp->next = struts;
+			if(struts) {
+				struts->prev = sp;
+			} else {
+				strutsTail = sp;
+			}
+			struts = sp;
+
+		}
+		JXFree(value);
+		return;
+	}
+
+	/* Next try to read _NET_WM_STRUT */
+	/* Format is: left_width, right_width, top_width, bottom_width */
+	status = JXGetWindowProperty(display, np->window,
+		atoms[ATOM_NET_WM_STRUT], 0, 4, False, XA_CARDINAL,
+		&actualType, &actualFormat, &count, &bytesLeft, &value);
+	if(status == Success) {
+		if(count == 4) {
+			lvalue = (long*)value;
+			leftWidth = lvalue[0];
+			rightWidth = lvalue[1];
+			topHeight = lvalue[2];
+			bottomHeight = lvalue[3];
+
+			if(leftWidth > 0) {
+				box.x = 0;
+				box.width = leftWidth;
+			}
+
+			if(rightWidth > 0) {
+				box.x = rootWidth - rightWidth;
+				box.width = rightWidth;
+			}
+
+			if(topHeight > 0) {
+				box.y = 0;
+				box.height = topHeight;
+			}
+
+			if(bottomHeight > 0) {
+				box.y = rootHeight - bottomHeight;
+				box.height = bottomHeight;
+			}
+
+			sp = Allocate(sizeof(Strut));
+			sp->client = np;
+			sp->box = box;
+			sp->prev = NULL;
+			sp->next = struts;
+			if(struts) {
+				struts->prev = sp;
+			} else {
+				strutsTail = sp;
+			}
+			struts = sp;
+
+		}
+		JXFree(value);
+		return;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void GetScreenBounds(const ScreenType *sp, BoundingBox *box) {
+
+	box->x = sp->x;
+	box->y = sp->y;
+	box->width = sp->width;
+	box->height = sp->height;
+
+}
+
+/****************************************************************************
+ * Shrink dest such that it does not intersect with src.
+ ****************************************************************************/
+void SubtractBounds(const BoundingBox *src, BoundingBox *dest) {
+
+	BoundingBox boxes[4];
+
+	if(src->x + src->width <= dest->x) {
+		return;
+	}
+	if(src->y + src->height <= dest->y) {
+		return;
+	}
+	if(dest->x + dest->width <= src->x) {
+		return;
+	}
+	if(dest->y + dest->height <= src->y) {
+		return;
+	}
+
+	/* There are four ways to do this:
+	 *  0. Increase the x-coordinate and decrease the width of dest.
+	 *  1. Increase the y-coordinate and decrease the height of dest.
+	 *  2. Decrease the width of dest.
+	 *  3. Decrease the height of dest.
+	 * We will chose the option which leaves the greatest area.
+	 * Note that negative areas are possible.
+	 */
+
+	/* 0 */
+	boxes[0] = *dest;
+	boxes[0].x = src->x + src->width;
+	boxes[0].width = dest->x + dest->width - boxes[0].x;
+
+	/* 1 */
+	boxes[1] = *dest;
+	boxes[1].y = src->y + src->height;
+	boxes[1].height = dest->y + dest->height - boxes[1].y;
+
+	/* 2 */
+	boxes[2] = *dest;
+	boxes[2].width = src->x - dest->x;
+
+	/* 3 */
+	boxes[3] = *dest;
+	boxes[3].height = src->y - dest->y;
+
+	/* 0 and 1, winner in 0. */
+	if(boxes[0].width * boxes[0].height < boxes[1].width * boxes[1].height) {
+		boxes[0] = boxes[1];
+	}
+
+	/* 2 and 3, winner in 2. */
+	if(boxes[2].width * boxes[2].height < boxes[3].width * boxes[3].height) {
+		boxes[2] = boxes[3];
+	}
+
+	/* 0 and 2, winner in dest. */
+	if(boxes[0].width * boxes[0].height < boxes[2].width * boxes[2].height) {
+		*dest = boxes[2];
+	} else {
+		*dest = boxes[0];
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void UpdateTrayBounds(BoundingBox *box, unsigned int layer) {
+
+	TrayType *tp;
+	BoundingBox src;
+	BoundingBox last;
+
+	for(tp = GetTrays(); tp; tp = tp->next) {
+
+		if(tp->layer > layer && !tp->autoHide) {
+
+			src.x = tp->x;
+			src.y = tp->y;
+			src.width = tp->width;
+			src.height = tp->height;
+
+			last = *box;
+			SubtractBounds(&src, box);
+			if(box->width * box->height <= 0) {
+				*box = last;
+				break;
+			}
+
+		}
+
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void UpdateStrutBounds(BoundingBox *box) {
+
+	Strut *sp;
+	BoundingBox last;
+
+	for(sp = struts; sp; sp = sp->next) {
+		if(sp->client->state.desktop == currentDesktop
+			|| (sp->client->state.status & STAT_STICKY)) {
+			continue;
+		}
+		last = *box;
+		SubtractBounds(&sp->box, box);
+		if(box->width * box->height <= 0) {
+			*box = last;
+			break;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void PlaceClient(ClientNode *np, int alreadyMapped) {
+
+	BoundingBox box;
+	int north, south, east, west;
+	const ScreenType *sp;
+	int cascadeIndex;
+	int overflow;
+
+	Assert(np);
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	if(np->x + np->width > rootWidth || np->y + np->height > rootWidth) {
+		overflow = 1;
+	} else {
+		overflow = 0;
+	}
+
+	sp = GetMouseScreen();
+	GetScreenBounds(sp, &box);
+
+	if(!overflow && (alreadyMapped
+		|| (!(np->state.status & STAT_PIGNORE)
+		&& (np->sizeFlags & (PPosition | USPosition))))) {
+
+		GravitateClient(np, 0);
+
+	} else {
+
+		UpdateTrayBounds(&box, np->state.layer);
+		UpdateStrutBounds(&box);
+
+		cascadeIndex = sp->index * desktopCount + currentDesktop;
+
+		/* Set the cascaded location. */
+		np->x = box.x + west + cascadeOffsets[cascadeIndex];
+		np->y = box.y + north + cascadeOffsets[cascadeIndex];
+		cascadeOffsets[cascadeIndex] += borderWidth + titleHeight;
+
+		/* Check for cascade overflow. */
+		overflow = 0;
+		if(np->x + np->width - box.x > box.width) {
+			overflow = 1;
+		} else if(np->y + np->height - box.y > box.height) {
+			overflow = 1;
+		}
+
+		if(overflow) {
+
+			cascadeOffsets[cascadeIndex] = borderWidth + titleHeight;
+			np->x = box.x + west + cascadeOffsets[cascadeIndex];
+			np->y = box.y + north + cascadeOffsets[cascadeIndex];
+
+			/* Check for client overflow. */
+			overflow = 0;
+			if(np->x + np->width - box.x > box.width) {
+				overflow = 1;
+			} else if(np->y + np->height - box.y > box.height) {
+				overflow = 1;
+			}
+
+			/* Update cascade position or position client. */
+			if(overflow) {
+				np->x = box.x + west;
+				np->y = box.y + north;
+			} else {
+				cascadeOffsets[cascadeIndex] += borderWidth + titleHeight;
+			}
+
+		}
+
+	}
+
+	if(np->state.status & STAT_FULLSCREEN) {
+		JXMoveWindow(display, np->parent, sp->x, sp->y);
+	} else {
+		JXMoveWindow(display, np->parent, np->x - west, np->y - north);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ConstrainSize(ClientNode *np) {
+
+	BoundingBox box;
+	const ScreenType *sp;
+	int north, south, east, west;
+	float ratio, minr, maxr;
+
+	Assert(np);
+
+	/* Determine if the size needs to be constrained. */
+	sp = GetCurrentScreen(np->x, np->y);
+	if(np->width < sp->width && np->height < sp->height) {
+		return;
+	}
+
+	/* Constrain the size. */
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	GetScreenBounds(sp, &box);
+	UpdateTrayBounds(&box, np->state.layer);
+	UpdateStrutBounds(&box);
+
+	box.x += west;
+	box.y += north;
+	box.width -= east + west;
+	box.height -= north + south;
+
+	if(box.width > np->maxWidth) {
+		box.width = np->maxWidth;
+	}
+	if(box.height > np->maxHeight) {
+		box.height = np->maxHeight;
+	}
+
+	if(np->sizeFlags & PAspect) {
+
+		ratio = (float)box.width / box.height;
+
+		minr = (float)np->aspect.minx / np->aspect.miny;
+		if(ratio < minr) {
+			box.height = (int)((float)box.width / minr);
+		}
+
+		maxr = (float)np->aspect.maxx / np->aspect.maxy;
+		if(ratio > maxr) {
+			box.width = (int)((float)box.height * maxr);
+		}
+
+	}
+
+	np->x = box.x;
+	np->y = box.y;
+	np->width = box.width - (box.width % np->xinc);
+	np->height = box.height - (box.height % np->yinc);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void PlaceMaximizedClient(ClientNode *np) {
+
+	BoundingBox box;
+	const ScreenType *sp;
+	int north, south, east, west;
+	float ratio, minr, maxr;
+
+	np->oldx = np->x;
+	np->oldy = np->y;
+	np->oldWidth = np->width;
+	np->oldHeight = np->height;
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	sp = GetCurrentScreen(
+		np->x + (east + west + np->width) / 2,
+		np->y + (north + south + np->height) / 2);
+	GetScreenBounds(sp, &box);
+	UpdateTrayBounds(&box, np->state.layer);
+	UpdateStrutBounds(&box);
+
+	box.x += west;
+	box.y += north;
+	box.width -= east + west;
+	box.height -= north + south;
+
+	if(box.width > np->maxWidth) {
+		box.width = np->maxWidth;
+	}
+	if(box.height > np->maxHeight) {
+		box.height = np->maxHeight;
+	}
+
+	if(np->sizeFlags & PAspect) {
+
+		ratio = (float)box.width / box.height;
+
+		minr = (float)np->aspect.minx / np->aspect.miny;
+		if(ratio < minr) {
+			box.height = (int)((float)box.width / minr);
+		}
+
+		maxr = (float)np->aspect.maxx / np->aspect.maxy;
+		if(ratio > maxr) {
+			box.width = (int)((float)box.height * maxr);
+		}
+
+	}
+
+	np->x = box.x;
+	np->y = box.y;
+	np->width = box.width - (box.width % np->xinc);
+	np->height = box.height - (box.height % np->yinc);
+
+	np->state.status |= STAT_MAXIMIZED;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void GetGravityDelta(const ClientNode *np, int *x, int  *y) {
+
+	int north, south, east, west;
+
+	Assert(np);
+	Assert(x);
+	Assert(y);
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	switch(np->gravity) {
+	case NorthWestGravity:
+		*y = -north;
+		*x = -west;
+		break;
+	case NorthGravity:
+		*y = -north;
+		break;
+	case NorthEastGravity:
+		*y = -north;
+		*x = west;
+		break;
+	case WestGravity:
+		*x = -west;
+		break;
+	case CenterGravity:
+		*y = (north + south) / 2;
+		*x = (east + west) / 2;
+		break;
+	case EastGravity:
+		*x = west;
+		break;
+	case SouthWestGravity:
+		*y = south;
+		*x = -west;
+		break;
+	case SouthGravity:
+		*y = south;
+		break;
+	case SouthEastGravity:
+		*y = south;
+		*x = west;
+		break;
+	default: /* Static */
+		*x = 0;
+		*y = 0;
+		break;
+	}
+
+}
+
+/****************************************************************************
+ * Move the window in the specified direction for reparenting.
+ ****************************************************************************/
+void GravitateClient(ClientNode *np, int negate) {
+
+	int deltax, deltay;
+
+	Assert(np);
+
+	GetGravityDelta(np, &deltax, &deltay);
+
+	if(negate) {
+		np->x += deltax;
+		np->y += deltay;
+	} else {
+		np->x -= deltax;
+		np->y -= deltay;
+	}
+
+}
+
diff --git a/src/place.h b/src/place.h
new file mode 100644
index 0000000..7508881
--- /dev/null
+++ b/src/place.h
@@ -0,0 +1,34 @@
+/**
+ * @file place.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for client placement functions.
+ *
+ */
+
+#ifndef PLACE_H
+#define PLACE_H
+
+struct ClientNode;
+
+/*@{*/
+void InitializePlacement();
+void StartupPlacement();
+void ShutdownPlacement();
+void DestroyPlacement();
+/*@}*/
+
+void RemoveClientStrut(struct ClientNode *np);
+void ReadClientStrut(struct ClientNode *np);
+
+void PlaceClient(struct ClientNode *np, int alreadyMapped);
+void PlaceMaximizedClient(struct ClientNode *np);
+void GravitateClient(struct ClientNode *np, int negate);
+
+void GetGravityDelta(const struct ClientNode *np, int *x, int *y);
+
+void ConstrainSize(struct ClientNode *np);
+
+#endif
+
diff --git a/src/popup.c b/src/popup.c
new file mode 100644
index 0000000..c9caafc
--- /dev/null
+++ b/src/popup.c
@@ -0,0 +1,232 @@
+/****************************************************************************
+ * Functions for displaying popup windows.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "popup.h"
+#include "main.h"
+#include "color.h"
+#include "font.h"
+#include "screen.h"
+#include "cursor.h"
+#include "error.h"
+#include "timing.h"
+#include "misc.h"
+
+#define DEFAULT_POPUP_DELAY 600
+
+typedef struct PopupType {
+	int isActive;
+	int x, y;   /* The coordinates of the upper-left corner of the popup. */
+	int mx, my; /* The mouse position when the popup was created. */
+	int width, height;
+	char *text;
+	Window window;
+} PopupType;
+
+static PopupType popup;
+static int popupEnabled;
+int popupDelay;
+
+static void DrawPopup();
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializePopup() {
+	popupDelay = DEFAULT_POPUP_DELAY;
+	popupEnabled = 1;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupPopup() {
+	popup.isActive = 0;
+	popup.text = NULL;
+	popup.window = None;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownPopup() {
+	if(popup.text) {
+		Release(popup.text);
+		popup.text = NULL;
+	}
+	if(popup.window != None) {
+		JXDestroyWindow(display, popup.window);
+		popup.window = None;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyPopup() {
+}
+
+/****************************************************************************
+ * Show a popup window.
+ * x - The x coordinate of the popup window.
+ * y - The y coordinate of the popup window.
+ * text - The text to display in the popup.
+ ****************************************************************************/
+void ShowPopup(int x, int y, const char *text) {
+
+	unsigned long attrMask;
+	XSetWindowAttributes attr;
+	const ScreenType *sp;
+
+	Assert(text);
+
+	if(!popupEnabled) {
+		return;
+	}
+
+	if(popup.text) {
+		Release(popup.text);
+		popup.text = NULL;
+	}
+
+	if(!strlen(text)) {
+		return;
+	}
+
+	popup.text = CopyString(text);
+
+	popup.height = GetStringHeight(FONT_POPUP);
+	popup.width = GetStringWidth(FONT_POPUP, popup.text);
+
+	popup.height += 2;
+	popup.width += 8; 
+
+	sp = GetCurrentScreen(x, y);
+
+	if(popup.width > sp->width) {
+		popup.width = sp->width;
+	}
+
+	popup.x = x;
+	popup.y = y - popup.height - 2;
+
+	if(popup.width + popup.x >= sp->width) {
+		popup.x = sp->width - popup.width - 2;
+	}
+	if(popup.height + popup.y >= sp->height) {
+		popup.y = sp->height - popup.height - 2;
+	}
+
+	if(popup.window == None) {
+
+		attrMask = 0;
+
+		attrMask |= CWEventMask;
+		attr.event_mask
+			= ExposureMask
+			| PointerMotionMask | PointerMotionHintMask;
+
+		attrMask |= CWSaveUnder;
+		attr.save_under = True;
+
+		attrMask |= CWBackPixel;
+		attr.background_pixel = colors[COLOR_POPUP_BG];
+
+		attrMask |= CWBorderPixel;
+		attr.border_pixel = colors[COLOR_POPUP_OUTLINE];
+
+		attrMask |= CWDontPropagate;
+		attr.do_not_propagate_mask
+			= PointerMotionMask
+			| ButtonPressMask
+			| ButtonReleaseMask;
+
+		popup.window = JXCreateWindow(display, rootWindow, popup.x, popup.y,
+			popup.width, popup.height, 1, CopyFromParent,
+			InputOutput, CopyFromParent, attrMask, &attr);
+
+	} else {
+		JXMoveResizeWindow(display, popup.window, popup.x, popup.y,
+			popup.width, popup.height);
+	}
+
+	popup.mx = x;
+	popup.my = y;
+
+	if(!popup.isActive) {
+		JXMapRaised(display, popup.window);
+		popup.isActive = 1;
+	} else {
+		DrawPopup();
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetPopupEnabled(int e) {
+	popupEnabled = e;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetPopupDelay(const char *str) {
+
+	int temp;
+
+	if(str == NULL) {
+		return;
+	}
+
+	temp = atoi(str);
+
+	if(temp < 0) {
+		Warning("invalid popup delay specified: %s\n", str);
+	} else {
+		popupDelay = temp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SignalPopup(const TimeType *now, int x, int y) {
+
+	if(popup.isActive) {
+		if(abs(popup.mx - x) > 2 || abs(popup.my - y) > 2) {
+			JXUnmapWindow(display, popup.window);
+			popup.isActive = 0;
+		}
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int ProcessPopupEvent(const XEvent *event) {
+
+	if(popup.isActive && event->xany.window == popup.window) {
+		if(event->type == Expose) {
+			DrawPopup();
+			return 1;
+		} else if(event->type == MotionNotify) {
+			JXUnmapWindow(display, popup.window);
+			popup.isActive = 0;
+			return 1;
+		}
+	}
+
+	return 0;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DrawPopup() {
+
+	Assert(popup.isActive);
+
+	JXClearWindow(display, popup.window);
+	RenderString(popup.window, FONT_POPUP, COLOR_POPUP_FG, 4, 1,
+		popup.width, NULL, popup.text);
+
+}
+
diff --git a/src/popup.h b/src/popup.h
new file mode 100644
index 0000000..21e84db
--- /dev/null
+++ b/src/popup.h
@@ -0,0 +1,35 @@
+/**
+ * @file popup.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for popup functions.
+ *
+ */
+
+#ifndef POPUP_H
+#define POPUP_H
+
+#define POPUP_DELTA 2
+
+struct TimeType;
+
+/*@{*/
+void InitializePopup();
+void StartupPopup();
+void ShutdownPopup();
+void DestroyPopup();
+/*@}*/
+
+void ShowPopup(int x, int y, const char *text);
+
+void SetPopupEnabled(int e);
+void SetPopupDelay(const char *str);
+
+void SignalPopup(const struct TimeType *now, int x, int y);
+int ProcessPopupEvent(const XEvent *event);
+
+extern int popupDelay;
+
+#endif
+
diff --git a/src/render.c b/src/render.c
new file mode 100644
index 0000000..d2d747e
--- /dev/null
+++ b/src/render.c
@@ -0,0 +1,226 @@
+/****************************************************************************
+ * Functions to render icons using the XRender extension.
+ * Copyright (C) 2005 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "render.h"
+#include "icon.h"
+#include "image.h"
+#include "main.h"
+#include "color.h"
+#include "error.h"
+
+#ifdef USE_XRENDER
+static int haveRender = 0;
+#endif
+
+/****************************************************************************
+ ****************************************************************************/
+void QueryRenderExtension()
+{
+
+#ifdef USE_XRENDER
+	int event, error;
+	Bool rc;
+
+	rc = JXRenderQueryExtension(display, &event, &error);
+	if(rc == True) {
+		haveRender = 1;
+		Debug("render extension enabled");
+	} else {
+		haveRender = 0;
+		Debug("render extension disabled");
+	}
+
+	if(haveRender && rootDepth < 24) {
+		Warning("color depth is %d, disabling icon alpha channel", rootDepth);
+		haveRender = 0;
+	}
+
+#endif
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int PutScaledRenderIcon(IconNode *icon, ScaledIconNode *node, Drawable d,
+	int x, int y)
+{
+
+#ifdef USE_XRENDER
+
+	Picture dest;
+	Picture source;
+	XRenderPictFormat *fp;
+	int width, height;
+
+	Assert(icon);
+
+	if(!haveRender) {
+		return 0;
+	}
+
+	source = node->imagePicture;
+	if(source != None) {
+
+		fp = JXRenderFindVisualFormat(display, rootVisual);
+		Assert(fp);
+
+		dest = JXRenderCreatePicture(display, d, fp, 0, NULL);
+
+		if(node->width == 0) {
+			width = icon->image->width;
+		} else {
+			width = node->width;
+		}
+		if(node->height == 0) {
+			height = icon->image->height;
+		} else {
+			height = node->height;
+		}
+
+		JXRenderComposite(display, PictOpOver, source, None, dest,
+			0, 0, 0, 0, x, y, width, height);
+
+		JXRenderFreePicture(display, dest);
+
+	}
+
+	return 1;
+
+#else
+
+	return 0;
+
+#endif
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+ScaledIconNode *CreateScaledRenderIcon(IconNode *icon,
+	int width, int height) {
+
+	ScaledIconNode *result = NULL;
+
+#ifdef USE_XRENDER
+
+	XRenderPictureAttributes picAttributes;
+	XRenderPictFormat picFormat;
+	XRenderPictFormat *fp;
+	XColor color;
+	GC maskGC;
+	XImage *destImage;
+	XImage *destMask;
+	unsigned long alpha;
+	int index;
+	int x, y;
+	double scalex, scaley;
+	double srcx, srcy;
+	int imageLine;
+	int maskLine;
+
+	Assert(icon);
+
+	if(!haveRender) {
+		return NULL;
+	}
+
+	result = Allocate(sizeof(ScaledIconNode));
+	result->next = icon->nodes;
+	icon->nodes = result;
+
+	if(width == 0) {
+		width = icon->image->width;
+	}
+	if(height == 0) {
+		height = icon->image->height;
+	}
+	result->width = width;
+	result->height = height;
+
+	scalex = (double)icon->image->width / width;
+	scaley = (double)icon->image->height / height;
+
+	result->mask = JXCreatePixmap(display, rootWindow, width, height, 8);
+	maskGC = JXCreateGC(display, result->mask, 0, NULL);
+	result->image = JXCreatePixmap(display, rootWindow,
+		width, height, rootDepth);
+
+	destImage = JXCreateImage(display, rootVisual, rootDepth, ZPixmap, 0,
+		NULL, width, height, 8, 0);
+	destImage->data = Allocate(sizeof(unsigned long) * width * height);
+
+	destMask = JXCreateImage(display, rootVisual, 8, ZPixmap, 0,
+		NULL, width, height, 8, 0);
+	destMask->data = Allocate(width * height);
+
+	imageLine = 0;
+	maskLine = 0;
+	srcy = 0.0;
+	for(y = 0; y < height; y++) {
+		srcx = 0.0;
+		for(x = 0; x < width; x++) {
+
+			index = (int)srcy * icon->image->width + (int)srcx;
+			alpha = (icon->image->data[index] >> 24) & 0xFFUL;
+			color.red = ((icon->image->data[index] >> 16) & 0xFFUL) * 257;
+			color.green = ((icon->image->data[index] >> 8) & 0xFFUL) * 257;
+			color.blue = (icon->image->data[index] & 0xFFUL) * 257;
+
+			GetColor(&color);
+			XPutPixel(destImage, x, y, color.pixel);
+			destMask->data[maskLine + x] = alpha * 257;
+
+			srcx += scalex;
+
+		}
+		srcy += scaley;
+		imageLine += destImage->bytes_per_line;
+		maskLine += destMask->bytes_per_line;
+	}
+
+	/* Render the image data to the image pixmap. */
+	JXPutImage(display, result->image, rootGC, destImage, 0, 0, 0, 0,
+		width, height);
+	Release(destImage->data);
+	destImage->data = NULL;
+	JXDestroyImage(destImage);
+
+	/* Render the alpha data to the mask pixmap. */
+	JXPutImage(display, result->mask, maskGC, destMask, 0, 0, 0, 0,
+		width, height);
+	Release(destMask->data);
+	destMask->data = NULL;
+	JXDestroyImage(destMask);
+	JXFreeGC(display, maskGC);
+
+	/* Create the render picture. */
+	picFormat.type = PictTypeDirect;
+	picFormat.depth = 8;
+	picFormat.direct.alphaMask = 0xFF;
+	fp = JXRenderFindFormat(display,
+		PictFormatType | PictFormatDepth | PictFormatAlphaMask,
+		&picFormat, 0);
+	Assert(fp);
+	result->maskPicture = JXRenderCreatePicture(display, result->mask,
+		fp, 0, NULL);
+	picAttributes.alpha_map = result->maskPicture;
+	fp = JXRenderFindVisualFormat(display, rootVisual);
+	Assert(fp);
+	result->imagePicture = JXRenderCreatePicture(display, result->image,
+		fp, CPAlphaMap, &picAttributes);
+
+	/* Free unneeded pixmaps. */
+	JXFreePixmap(display, result->image);
+	result->image = None;
+	JXFreePixmap(display, result->mask);
+	result->mask = None;
+
+#endif
+
+	return result;
+
+}
+
diff --git a/src/render.h b/src/render.h
new file mode 100644
index 0000000..1e7164b
--- /dev/null
+++ b/src/render.h
@@ -0,0 +1,25 @@
+/**
+ * @file render.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Functions to render icons using the XRender extension.
+ *
+ */
+
+#ifndef RENDER_H
+#define RENDER_H
+
+struct IconNode;
+struct ScaledIconNode;
+
+void QueryRenderExtension();
+
+int PutScaledRenderIcon(struct IconNode *icon, struct ScaledIconNode *node,
+	Drawable d, int x, int y);
+
+struct ScaledIconNode *CreateScaledRenderIcon(struct IconNode *icon,
+	int width, int height);
+
+#endif
+
diff --git a/src/resize.c b/src/resize.c
new file mode 100644
index 0000000..c7961f9
--- /dev/null
+++ b/src/resize.c
@@ -0,0 +1,491 @@
+/**
+ * @file resize.c
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Functions to handle resizing client windows.
+ *
+ */
+
+#include "jwm.h"
+#include "resize.h"
+#include "client.h"
+#include "outline.h"
+#include "main.h"
+#include "cursor.h"
+#include "misc.h"
+#include "pager.h"
+#include "status.h"
+#include "key.h"
+#include "event.h"
+#include "border.h"
+
+static ResizeModeType resizeMode = RESIZE_OPAQUE;
+
+static int shouldStopResize;
+
+static void StopResize(ClientNode *np);
+static void ResizeController(int wasDestroyed);
+static void FixWidth(ClientNode *np);
+static void FixHeight(ClientNode *np);
+
+/** Set the resize mode to use. */
+void SetResizeMode(ResizeModeType mode) {
+	resizeMode = mode;
+}
+
+/** Callback to stop a resize. */
+void ResizeController(int wasDestroyed) {
+	if(resizeMode == RESIZE_OUTLINE) {
+		ClearOutline();
+	}
+	JXUngrabPointer(display, CurrentTime);
+	JXUngrabKeyboard(display, CurrentTime);
+	DestroyResizeWindow();
+	shouldStopResize = 1;
+}
+
+/** Resize a client window (mouse initiated). */
+void ResizeClient(ClientNode *np, BorderActionType action,
+	int startx, int starty) {
+
+	XEvent event;
+	int oldx, oldy;
+	int oldw, oldh;
+	int gwidth, gheight;
+	int lastgwidth, lastgheight;
+	int delta;
+	int north, south, east, west;
+	float ratio, minr, maxr;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_RESIZE)) {
+		return;
+	}
+
+	if(!GrabMouseForResize(action)) {
+		Debug("ResizeClient: could not grab mouse");
+		return;
+	}
+
+	if(np->state.status & STAT_SHADED) {
+		action &= ~(BA_RESIZE_N | BA_RESIZE_S);
+	}
+
+	np->controller = ResizeController;
+	shouldStopResize = 0;
+
+	oldx = np->x;
+	oldy = np->y;
+	oldw = np->width;
+	oldh = np->height;
+
+	gwidth = (np->width - np->baseWidth) / np->xinc;
+	gheight = (np->height - np->baseHeight) / np->yinc;
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	startx += np->x - west;
+	starty += np->y - north;
+
+	CreateResizeWindow(np);
+	UpdateResizeWindow(np, gwidth, gheight);
+
+	if(!(GetMouseMask() & Button1Mask)) {
+		StopResize(np);
+		return;
+	}
+
+	for(;;) {
+
+		WaitForEvent(&event);
+
+		if(shouldStopResize) {
+			np->controller = NULL;
+			return;
+		}
+
+		switch(event.type) {
+		case ButtonRelease:
+			if(event.xbutton.button == Button1) {
+				StopResize(np);
+				return;
+			}
+			break;
+		case MotionNotify:
+
+			SetMousePosition(event.xmotion.x_root, event.xmotion.y_root);
+			DiscardMotionEvents(&event, np->window);
+
+			if(action & BA_RESIZE_N) {
+				delta = (event.xmotion.y - starty) / np->yinc;
+				delta *= np->yinc;
+				if(oldh - delta >= np->minHeight
+					&& (oldh - delta <= np->maxHeight || delta > 0)) {
+					np->height = oldh - delta;
+					np->y = oldy + delta;
+				}
+				if(!(action & (BA_RESIZE_E | BA_RESIZE_W))) {
+					FixWidth(np);
+				}
+			}
+			if(action & BA_RESIZE_S) {
+				delta = (event.xmotion.y - starty) / np->yinc;
+				delta *= np->yinc;
+				np->height = oldh + delta;
+				np->height = Max(np->height, np->minHeight);
+				np->height = Min(np->height, np->maxHeight);
+				if(!(action & (BA_RESIZE_E | BA_RESIZE_W))) {
+					FixWidth(np);
+				}
+			}
+			if(action & BA_RESIZE_E) {
+				delta = (event.xmotion.x - startx) / np->xinc;
+				delta *= np->xinc;
+				np->width = oldw + delta;
+				np->width = Max(np->width, np->minWidth);
+				np->width = Min(np->width, np->maxWidth);
+				if(!(action & (BA_RESIZE_N | BA_RESIZE_S))) {
+					FixHeight(np);
+				}
+			}
+			if(action & BA_RESIZE_W) {
+				delta = (event.xmotion.x - startx) / np->xinc;
+				delta *= np->xinc;
+				if(oldw - delta >= np->minWidth
+					&& (oldw - delta <= np->maxWidth || delta > 0)) {
+					np->width = oldw - delta;
+					np->x = oldx + delta;
+				}
+				if(!(action & (BA_RESIZE_N | BA_RESIZE_S))) {
+					FixHeight(np);
+				}
+			}
+
+			if(np->sizeFlags & PAspect) {
+				if((action & (BA_RESIZE_N | BA_RESIZE_S)) &&
+					(action & (BA_RESIZE_E | BA_RESIZE_W))) {
+
+					ratio = (float)np->width / np->height;
+
+					minr = (float)np->aspect.minx / np->aspect.miny;
+					if(ratio < minr) {
+						delta = np->width;
+						np->width = (int)((float)np->height * minr);
+						if(action & BA_RESIZE_W) {
+							np->x -= np->width - delta;
+						}
+					}
+
+					maxr = (float)np->aspect.maxx / np->aspect.maxy;
+					if(ratio > maxr) {
+						delta = np->height;
+						np->height = (int)((float)np->width / maxr);
+						if(action & BA_RESIZE_N) {
+							np->y -= np->height - delta;
+						}
+					}
+
+				}
+			}
+
+			lastgwidth = gwidth;
+			lastgheight = gheight;
+
+			gwidth = (np->width - np->baseWidth) / np->xinc;
+			gheight = (np->height - np->baseHeight) / np->yinc;
+
+			if(lastgheight != gheight || lastgwidth != gwidth) {
+
+				if(np->state.status & STAT_MAXIMIZED) {
+					np->state.status &= ~STAT_MAXIMIZED;
+					WriteState(np);
+					SendConfigureEvent(np);
+				}
+
+				UpdateResizeWindow(np, gwidth, gheight);
+
+				if(resizeMode == RESIZE_OUTLINE) {
+					ClearOutline();
+					if(np->state.status & STAT_SHADED) {
+						DrawOutline(np->x - west, np->y - north,
+							np->width + west + east, north + south);
+					} else {
+						DrawOutline(np->x - west, np->y - north,
+							np->width + west + east,
+							np->height + north + south);
+					}
+				} else {
+					if(np->state.status & STAT_SHADED) {
+						JXMoveResizeWindow(display, np->parent,
+							np->x - west, np->y - north,
+							np->width + west + east, north + south);
+					} else {
+						JXMoveResizeWindow(display, np->parent,
+							np->x - west, np->y - north,
+							np->width + west + east,
+							np->height + north + south);
+					}
+					JXMoveResizeWindow(display, np->window, west,
+						north, np->width, np->height);
+					SendConfigureEvent(np);
+				}
+
+				UpdatePager();
+
+			}
+
+			break;
+		default:
+			break;
+		}
+	}
+
+}
+
+/** Resize a client window (keyboard or menu initiated). */
+void ResizeClientKeyboard(ClientNode *np) {
+
+	XEvent event;
+	int gwidth, gheight;
+	int lastgwidth, lastgheight;
+	int north, south, east, west;
+	int deltax, deltay;
+	float ratio, minr, maxr;
+
+	Assert(np);
+
+	if(!(np->state.border & BORDER_RESIZE)) {
+		return;
+	}
+
+	if(JXGrabKeyboard(display, np->window, True, GrabModeAsync,
+		GrabModeAsync, CurrentTime) != GrabSuccess) {
+		Debug("ResizeClientKeyboard: could not grab keyboard");
+		return;
+	}
+	GrabMouseForResize(BA_RESIZE_S | BA_RESIZE_E | BA_RESIZE);
+
+	np->controller = ResizeController;
+	shouldStopResize = 0;
+
+	gwidth = (np->width - np->baseWidth) / np->xinc;
+	gheight = (np->height - np->baseHeight) / np->yinc;
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	CreateResizeWindow(np);
+	UpdateResizeWindow(np, gwidth, gheight);
+
+	MoveMouse(rootWindow, np->x + np->width, np->y + np->height);
+	DiscardMotionEvents(&event, np->window);
+
+	for(;;) {
+
+		WaitForEvent(&event);
+
+		if(shouldStopResize) {
+			np->controller = NULL;
+			return;
+		}
+
+		deltax = 0;
+		deltay = 0;
+
+		if(event.type == KeyPress) {
+
+			while(JXCheckTypedWindowEvent(display, np->window, KeyPress, &event));
+
+			switch(GetKey(&event.xkey) & 0xFF) {
+			case KEY_UP:
+				deltay = Min(-np->yinc, -10);
+				break;
+			case KEY_DOWN:
+				deltay = Max(np->yinc, 10);
+				break;
+			case KEY_RIGHT:
+				deltax = Max(np->xinc, 10);
+				break;
+			case KEY_LEFT:
+				deltax = Min(-np->xinc, -10);
+				break;
+			default:
+				StopResize(np);
+				return;
+			}
+
+		} else if(event.type == MotionNotify) {
+
+			SetMousePosition(event.xmotion.x_root, event.xmotion.y_root);
+			DiscardMotionEvents(&event, np->window);
+
+			deltax = event.xmotion.x - (np->x + np->width);
+			deltay = event.xmotion.y - (np->y + np->height);
+
+		} else if(event.type == ButtonRelease) {
+
+			StopResize(np);
+			return;
+
+		}
+
+		if(abs(deltax) < np->xinc && abs(deltay) < np->yinc) {
+			continue;
+		}
+
+		deltay -= deltay % np->yinc;
+		np->height += deltay;
+		np->height = Max(np->height, np->minHeight);
+		np->height = Min(np->height, np->maxHeight);
+		deltax -= deltax % np->xinc;
+		np->width += deltax;
+		np->width = Max(np->width, np->minWidth);
+		np->width = Min(np->width, np->maxWidth);
+
+		if(np->sizeFlags & PAspect) {
+
+			ratio = (float)np->width / np->height;
+
+			minr = (float)np->aspect.minx / np->aspect.miny;
+			if(ratio < minr) {
+				np->width = (int)((float)np->height * minr);
+			}
+
+			maxr = (float)np->aspect.maxx / np->aspect.maxy;
+			if(ratio > maxr) {
+				np->height = (int)((float)np->width / maxr);
+			}
+
+		}
+
+		lastgwidth = gwidth;
+		lastgheight = gheight;
+		gwidth = (np->width - np->baseWidth) / np->xinc;
+		gheight = (np->height - np->baseHeight) / np->yinc;
+
+		if(lastgwidth != gwidth || lastgheight != gheight) {
+
+			if(np->state.status & STAT_MAXIMIZED) {
+				np->state.status &= ~STAT_MAXIMIZED;
+				WriteState(np);
+				SendConfigureEvent(np);
+			}
+
+			UpdateResizeWindow(np, gwidth, gheight);
+
+			if(resizeMode == RESIZE_OUTLINE) {
+				ClearOutline();
+				if(np->state.status & STAT_SHADED) {
+					DrawOutline(np->x - west, np->y - north,
+						np->width + west + east,
+						north + south);
+				} else {
+					DrawOutline(np->x - west, np->y - north,
+						np->width + west + east,
+						np->height + north + south);
+				}
+			} else {
+				if(np->state.status & STAT_SHADED) {
+					JXResizeWindow(display, np->parent,
+						np->width + west + east, north + south);
+				} else {
+					JXResizeWindow(display, np->parent,
+					np->width + west + east, np->height + north + south);
+				}
+				JXResizeWindow(display, np->window, np->width, np->height);
+				SendConfigureEvent(np);
+			}
+
+			UpdatePager();
+
+		}
+
+	}
+
+}
+
+/** Stop a resize action. */
+void StopResize(ClientNode *np) {
+
+	int north, south, east, west;
+
+	np->controller = NULL;
+
+	if(resizeMode == RESIZE_OUTLINE) {
+		ClearOutline();
+	}
+
+	JXUngrabPointer(display, CurrentTime);
+	JXUngrabKeyboard(display, CurrentTime);
+
+	DestroyResizeWindow();
+
+	GetBorderSize(np, &north, &south, &east, &west);
+
+	if(np->state.status & STAT_SHADED) {
+		JXMoveResizeWindow(display, np->parent,
+			np->x - west, np->y - north,
+			np->width + east + west, north + south);
+	} else {
+		JXMoveResizeWindow(display, np->parent,
+			np->x - west, np->y - north,
+			np->width + east + west,
+			np->height + north + south);
+	}
+	JXMoveResizeWindow(display, np->window, west,
+		north, np->width, np->height);
+	SendConfigureEvent(np);
+
+}
+
+/** Fix the width to match the aspect ratio. */
+void FixWidth(ClientNode *np) {
+
+	float ratio, minr, maxr;
+
+	Assert(np);
+
+	if((np->sizeFlags & PAspect) && np->height > 0) {
+
+		ratio = (float)np->width / np->height;
+
+		minr = (float)np->aspect.minx / np->aspect.miny;
+		if(ratio < minr) {
+			np->width = (int)((float)np->height * minr);
+		}
+
+		maxr = (float)np->aspect.maxx / np->aspect.maxy;
+		if(ratio > maxr) {
+			np->width = (int)((float)np->height * maxr);
+		}
+
+	}
+
+}
+
+/** Fix the height to match the aspect ratio. */
+void FixHeight(ClientNode *np) {
+
+	float ratio, minr, maxr;
+
+	Assert(np);
+
+	if((np->sizeFlags & PAspect) && np->height > 0) {
+
+		ratio = (float)np->width / np->height;
+
+		minr = (float)np->aspect.minx / np->aspect.miny;
+		if(ratio < minr) {
+			np->height = (int)((float)np->width / minr);
+		}
+
+		maxr = (float)np->aspect.maxx / np->aspect.maxy;
+		if(ratio > maxr) {
+			np->height = (int)((float)np->width / maxr);
+		}
+
+	}
+
+}
+
diff --git a/src/resize.h b/src/resize.h
new file mode 100644
index 0000000..92a407f
--- /dev/null
+++ b/src/resize.h
@@ -0,0 +1,42 @@
+/**
+ * @file resize.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Header for client window resize functions.
+ *
+ */
+
+#ifndef RESIZE_H
+#define RESIZE_H
+
+#include "border.h"
+
+struct ClientNode;
+
+typedef enum {
+	RESIZE_OPAQUE,   /**< Show window contents while resizing. */
+	RESIZE_OUTLINE   /**< Show an outline while resizing. */
+} ResizeModeType;
+
+/** Resize a client window.
+ * @param np The client to resize.
+ * @param action The location on the border where the move should take place.
+ * @param startx The starting mouse x-coordinate (window relative).
+ * @param starty The starting mouse y-coordinate (window relative).
+ */
+void ResizeClient(struct ClientNode *np, BorderActionType action,
+	int startx, int starty);
+
+/** Resize a client window using the keyboard (mouse optional).
+ * @param np The client to resize.
+ */
+void ResizeClientKeyboard(struct ClientNode *np);
+
+/** Set the resize mode to use.
+ * @param mode The resize mode to use.
+ */
+void SetResizeMode(ResizeModeType mode);
+
+#endif
+
diff --git a/src/root.c b/src/root.c
new file mode 100644
index 0000000..b110018
--- /dev/null
+++ b/src/root.c
@@ -0,0 +1,315 @@
+/***************************************************************************
+ * Functions to handle the root menu.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "root.h"
+#include "menu.h"
+#include "client.h"
+#include "main.h"
+#include "error.h"
+#include "confirm.h"
+#include "desktop.h"
+#include "misc.h"
+#include "winmenu.h"
+
+/* Allow for menus 0 to 9. */
+#define ROOT_MENU_COUNT 10
+
+static Menu *rootMenu[ROOT_MENU_COUNT];
+static int showExitConfirmation = 1;
+
+static void ExitHandler(ClientNode *np);
+static void PatchRootMenu(Menu *menu);
+static void UnpatchRootMenu(Menu *menu);
+
+static void RunRootCommand(const MenuAction *action);
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeRootMenu() {
+
+	int x;
+
+	for(x = 0; x < ROOT_MENU_COUNT; x++) {
+		rootMenu[x] = NULL;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void StartupRootMenu() {
+
+	int x, y;
+	int found;
+
+	for(x = 0; x < ROOT_MENU_COUNT; x++) {
+		if(rootMenu[x]) {
+			found = 0;
+			for(y = 0; y < x; y++) {
+				if(rootMenu[y] == rootMenu[x]) {
+					found = 1;
+					break;
+				}
+			}
+			if(!found) {
+				InitializeMenu(rootMenu[x]);
+			}
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShutdownRootMenu() {
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyRootMenu() {
+
+	int x, y;
+
+	for(x = 0; x < ROOT_MENU_COUNT; x++) {
+		if(rootMenu[x]) {
+			DestroyMenu(rootMenu[x]);
+			for(y = x + 1; y < ROOT_MENU_COUNT; y++) {
+				if(rootMenu[x] == rootMenu[y]) {
+					rootMenu[y] = NULL;
+				}
+			}
+			rootMenu[x] = NULL;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetRootMenu(const char *indexes, Menu *m) {
+
+	int x, y;
+	int index;
+	int found;
+
+	/* Loop over each index to consider. */
+	for(x = 0; indexes[x]; x++) {
+
+		/* Get the index and make sure it's in range. */
+		index = indexes[x] - '0';
+		if(index < 0 || index >= ROOT_MENU_COUNT) {
+			Warning("invalid root menu specified: \"%c\"", indexes[x]);
+			continue;
+		}
+
+		if(rootMenu[index] && rootMenu[index] != m) {
+
+			/* See if replacing this value will cause an orphan. */
+			found = 0;
+			for(y = 0; y < ROOT_MENU_COUNT; y++) {
+				if(x != y && rootMenu[y] == rootMenu[x]) {
+					found = 1;
+					break;
+				}
+			}
+
+			/* If we have an orphan, destroy it. */
+			if(!found) {
+				DestroyMenu(rootMenu[index]);
+			}
+
+		}
+
+		rootMenu[index] = m;
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetShowExitConfirmation(int v) {
+	showExitConfirmation = v;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int IsRootMenuDefined(int index) {
+	if(index >= 0 && index < ROOT_MENU_COUNT && rootMenu[index]) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void GetRootMenuSize(int index, int *width, int *height) {
+
+	if(!rootMenu[index]) {
+		*width = 0;
+		*height = 0;
+		return;
+	}
+
+	PatchRootMenu(rootMenu[index]);
+	*width = rootMenu[index]->width;
+	*height = rootMenu[index]->height;
+	UnpatchRootMenu(rootMenu[index]);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ShowRootMenu(int index, int x, int y) {
+
+	if(!rootMenu[index]) {
+		return 0;
+	}
+
+	PatchRootMenu(rootMenu[index]);
+	ShowMenu(rootMenu[index], RunRootCommand, x, y);
+	UnpatchRootMenu(rootMenu[index]);
+
+	return 1;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void PatchRootMenu(Menu *menu) {
+
+	MenuItem *item;
+
+	for(item = menu->items; item; item = item->next) {
+		if(item->submenu) {
+			PatchRootMenu(item->submenu);
+		}
+		if(item->action.type == MA_DESKTOP) {
+			item->submenu = CreateDesktopMenu(1 << currentDesktop);
+			InitializeMenu(item->submenu);
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void UnpatchRootMenu(Menu *menu) {
+
+	MenuItem *item;
+
+	for(item = menu->items; item; item = item->next) {
+		if(item->action.type == MA_DESKTOP) {
+			DestroyMenu(item->submenu);
+			item->submenu = NULL;
+		} else if(item->submenu) {
+			UnpatchRootMenu(item->submenu);
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ExitHandler(ClientNode *np) {
+	shouldExit = 1;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Restart() {
+	shouldRestart = 1;
+	shouldExit = 1;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Exit() {
+	if(showExitConfirmation) {
+		ShowConfirmDialog(NULL, ExitHandler,
+			"Exit JWM",
+			"Are you sure?",
+			NULL);
+	} else {
+		ExitHandler(NULL);
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void RunRootCommand(const MenuAction *action) {
+
+	switch(action->type) {
+
+	case MA_EXECUTE:
+		RunCommand(action->data.str);
+		break;
+	case MA_RESTART:
+		Restart();
+		break;
+	case MA_EXIT:
+		if(exitCommand) {
+			Release(exitCommand);
+		}
+		exitCommand = CopyString(action->data.str);
+		Exit();
+		break;
+	case MA_DESKTOP:
+		ChangeDesktop(action->data.i);
+		break;
+
+	case MA_SENDTO:
+	case MA_LAYER:
+	case MA_MAXIMIZE:
+	case MA_MINIMIZE:
+	case MA_RESTORE:
+	case MA_SHADE:
+	case MA_MOVE:
+	case MA_RESIZE:
+	case MA_KILL:
+	case MA_CLOSE:
+		ChooseWindow(action);
+		break;
+
+	default:
+		Debug("invalid RunRootCommand action: %d", action->type);
+		break;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void RunCommand(const char *command) {
+	char *displayString;
+	char *str;
+
+	if(!command) {
+		return;
+	}
+
+	displayString = DisplayString(display);
+
+	if(!fork()) {
+		if(!fork()) {
+			close(ConnectionNumber(display));
+			if(displayString && displayString[0]) {
+				str = malloc(strlen(displayString) + 9);
+				sprintf(str, "DISPLAY=%s", displayString);
+				putenv(str);
+			}
+			execl(SHELL_NAME, SHELL_NAME, "-c", command, NULL);
+			Warning("exec failed: (%s) %s", SHELL_NAME, command);
+			exit(1);
+		}
+		exit(0);
+	}
+
+	wait(NULL);
+
+}
+
diff --git a/src/root.h b/src/root.h
new file mode 100644
index 0000000..b546156
--- /dev/null
+++ b/src/root.h
@@ -0,0 +1,65 @@
+/**
+ * @file root.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the root menu functions.
+ *
+ */
+
+#ifndef ROOT_H
+#define ROOT_H
+
+struct Menu;
+
+/*@{*/
+void InitializeRootMenu();
+void StartupRootMenu();
+void ShutdownRootMenu();
+void DestroyRootMenu();
+/*@}*/
+
+/** Set the root menu to be used for the specified indexes.
+ * @param indexes The indexes (ASCII string of '0' to '9').
+ * @param m The menu to use for the specified indexes.
+ */
+void SetRootMenu(const char *indexes, struct Menu *m);
+
+/** Set whether a confirmation dialog is displayed on exit.
+ * @param v 1 to display confirmation, 0 to just exit.
+ */
+void SetShowExitConfirmation(int v);
+
+/** Determine if a root menu is defined for the specified index.
+ * @return 1 if it is defined, 0 if not.
+ */
+int IsRootMenuDefined(int index);
+
+/** Get the size of a root menu.
+ * @param index The root menu index.
+ * @param width The width output.
+ * @param height The height output.
+ */
+void GetRootMenuSize(int index, int *width, int *height);
+
+/** Show a root menu.
+ * @param index The root menu index.
+ * @param x The x-coordinate.
+ * @param y The y-coordinate.
+ * @return 1 if a menu was displayed, 0 if not.
+ */
+int ShowRootMenu(int index, int x, int y);
+
+/** Run a command.
+ * @param command The command to run (run in sh).
+ */
+void RunCommand(const char *command);
+
+/** Restart the window manager. */
+void Restart();
+
+/** Exit the window manager. */
+void Exit();
+
+#endif
+
diff --git a/src/screen.c b/src/screen.c
new file mode 100644
index 0000000..cc2b8fd
--- /dev/null
+++ b/src/screen.c
@@ -0,0 +1,138 @@
+/****************************************************************************
+ * Screen functions.
+ * Copyright (C) 2005 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "screen.h"
+#include "main.h"
+#include "cursor.h"
+
+static ScreenType *screens;
+static int screenCount;
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeScreens() {
+	screens = NULL;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupScreens() {
+#ifdef USE_XINERAMA
+
+	XineramaScreenInfo *info;
+	int x;
+
+	if(XineramaIsActive(display)) {
+
+		info = XineramaQueryScreens(display, &screenCount);
+
+		screens = Allocate(sizeof(ScreenType) * screenCount);
+		for(x = 0; x < screenCount; x++) {
+			screens[x].index = x;
+			screens[x].x = info[x].x_org;
+			screens[x].y = info[x].y_org;
+			screens[x].width = info[x].width;
+			screens[x].height = info[x].height;
+		}
+
+		JXFree(info);
+
+	} else {
+
+		screenCount = 1;
+		screens = Allocate(sizeof(ScreenType));
+		screens->index = 0;
+		screens->x = 0;
+		screens->y = 0;
+		screens->width = rootWidth;
+		screens->height = rootHeight;
+
+	}
+
+#else
+
+	screenCount = 1;
+	screens = Allocate(sizeof(ScreenType));
+	screens->index = 0;
+	screens->x = 0;
+	screens->y = 0;
+	screens->width = rootWidth;
+	screens->height = rootHeight;
+
+#endif /* USE_XINERAMA */
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownScreens() {
+	if(screens) {
+		Release(screens);
+		screens = NULL;
+	}
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyScreens() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+const ScreenType *GetCurrentScreen(int x, int y) {
+
+	ScreenType *sp;
+	int index;
+
+	for(index = 1; index < screenCount; index++) {
+		sp = &screens[index];
+		if(x >= sp->x && x < sp->x + sp->width) {
+			if(y >= sp->y && y <= sp->y + sp->height) {
+				return sp;
+			}
+		}
+	}
+
+	return &screens[0];
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+const ScreenType *GetMouseScreen() {
+#ifdef USE_XINERAMA
+
+	int x, y;
+
+	GetMousePosition(&x, &y);
+	return GetCurrentScreen(x, y);
+
+#else
+
+	return &screens[0];
+
+#endif
+}
+
+/****************************************************************************
+ ****************************************************************************/
+const ScreenType *GetScreen(int index) {
+
+	Assert(index >= 0);
+	Assert(index < screenCount);
+
+	return &screens[index];
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+int GetScreenCount() {
+
+	return screenCount;
+
+}
+
+
diff --git a/src/screen.h b/src/screen.h
new file mode 100644
index 0000000..2d9a351
--- /dev/null
+++ b/src/screen.h
@@ -0,0 +1,53 @@
+/**
+ * @file screen.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Header for screen functions.
+ *
+ * Note that screen here refers to physical monitors. Screens are
+ * determined using the xinerama extension (if available). There will
+ * always be at least one screen.
+ *
+ */
+
+#ifndef SCREEN_H
+#define SCREEN_H
+
+/** Structure to contain information about a screen. */
+typedef struct ScreenType {
+	int index;           /**< The index of this screen. */
+	int x, y;            /**< The location of this screen. */
+	int width, height;   /**< The size of this screen. */
+} ScreenType;
+
+void InitializeScreens();
+void StartupScreens();
+void ShutdownScreens();
+void DestroyScreens();
+
+/** Get the screen of the specified coordinates.
+ * @param x The x-coordinate.
+ * @param y The y-coordinate.
+ * @return The screen.
+ */
+const ScreenType *GetCurrentScreen(int x, int y);
+
+/** Get the screen containing the mouse.
+ * @return The screen containing the mouse.
+ */
+const ScreenType *GetMouseScreen();
+
+/** Get the screen of the specified index.
+ * @param index The screen index (0 based).
+ * @return The screen.
+ */
+const ScreenType *GetScreen(int index);
+
+/** Get the number of screens.
+ * @return The number of screens.
+ */
+int GetScreenCount();
+
+#endif
+
diff --git a/src/status.c b/src/status.c
new file mode 100644
index 0000000..88c7ddb
--- /dev/null
+++ b/src/status.c
@@ -0,0 +1,274 @@
+/*************************************************************************
+ * Functions for displaying window move/resize status.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ *************************************************************************/
+
+#include "jwm.h"
+#include "status.h"
+#include "font.h"
+#include "screen.h"
+#include "color.h"
+#include "main.h"
+#include "client.h"
+#include "error.h"
+
+typedef enum {
+	SW_INVALID,
+	SW_OFF,
+	SW_SCREEN,
+	SW_WINDOW,
+	SW_CORNER
+} StatusWindowType;
+
+static Window statusWindow;
+static unsigned int statusWindowHeight;
+static unsigned int statusWindowWidth;
+static int statusWindowX, statusWindowY;
+static StatusWindowType moveStatusType;
+static StatusWindowType resizeStatusType;
+
+static void CreateMoveResizeWindow(const ClientNode *np,
+	StatusWindowType type);
+static void DrawMoveResizeWindow(const ClientNode *np, StatusWindowType type);
+static void DestroyMoveResizeWindow();
+static void GetMoveResizeCoordinates(const ClientNode *np,
+	StatusWindowType type, int *x, int *y);
+static StatusWindowType ParseType(const char *str);
+
+/*************************************************************************
+ *************************************************************************/
+void GetMoveResizeCoordinates(const ClientNode *np, StatusWindowType type,
+	int *x, int *y) {
+
+	const ScreenType *sp;
+
+	if(type == SW_WINDOW) {
+		*x = np->x + np->width / 2 - statusWindowWidth / 2;
+		*y = np->y + np->height / 2 - statusWindowHeight / 2;
+		return;
+	}
+
+	sp = GetCurrentScreen(np->x, np->y);
+
+	if(type == SW_CORNER) {
+		*x = sp->x;
+		*y = sp->y;
+		return;
+	}
+
+	/* SW_SCREEN */
+
+	*x = sp->x + sp->width / 2 - statusWindowWidth / 2;
+	*y = sp->y + sp->height / 2 - statusWindowHeight / 2;
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void CreateMoveResizeWindow(const ClientNode *np, StatusWindowType type) {
+
+	XSetWindowAttributes attrs;
+
+	if(type == SW_OFF) {
+		return;
+	}
+
+	statusWindowHeight = GetStringHeight(FONT_MENU) + 8;
+	statusWindowWidth = GetStringWidth(FONT_MENU, " 00000 x 00000 ");
+
+	GetMoveResizeCoordinates(np, type, &statusWindowX, &statusWindowY);
+
+	attrs.background_pixel = colors[COLOR_MENU_BG];
+	attrs.save_under = True;
+	attrs.override_redirect = True;
+
+	statusWindow = JXCreateWindow(display, rootWindow,
+		statusWindowX, statusWindowY,
+		statusWindowWidth, statusWindowHeight, 0,
+		CopyFromParent, InputOutput, CopyFromParent,
+		CWBackPixel | CWOverrideRedirect | CWSaveUnder,
+		&attrs);
+
+	JXMapRaised(display, statusWindow);
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void DrawMoveResizeWindow(const ClientNode *np, StatusWindowType type) {
+
+	int x, y;
+
+	GetMoveResizeCoordinates(np, type, &x, &y);
+	if(x != statusWindowX || y != statusWindowX) {
+		statusWindowX = x;
+		statusWindowY = y;
+		JXMoveResizeWindow(display, statusWindow, x, y,
+			statusWindowWidth, statusWindowHeight);
+	}
+
+	JXSetForeground(display, rootGC, colors[COLOR_MENU_BG]);
+	JXFillRectangle(display, statusWindow, rootGC, 2, 2,
+		statusWindowWidth - 3, statusWindowHeight - 3);
+
+	JXSetForeground(display, rootGC, colors[COLOR_MENU_UP]);
+	JXDrawLine(display, statusWindow, rootGC,
+		0, 0, statusWindowWidth - 1, 0);
+	JXDrawLine(display, statusWindow, rootGC,
+		0, 1, statusWindowWidth - 2, 1);
+	JXDrawLine(display, statusWindow, rootGC,
+		0, 2, 0, statusWindowHeight - 1);
+	JXDrawLine(display, statusWindow, rootGC,
+		1, 2, 1, statusWindowHeight - 2);
+
+	JXSetForeground(display, rootGC, colors[COLOR_MENU_DOWN]);
+	JXDrawLine(display, statusWindow, rootGC,
+		1, statusWindowHeight - 1, statusWindowWidth - 1,
+		statusWindowHeight - 1);
+	JXDrawLine(display, statusWindow, rootGC,
+		2, statusWindowHeight - 2, statusWindowWidth - 1,
+		statusWindowHeight - 2);
+	JXDrawLine(display, statusWindow, rootGC,
+		statusWindowWidth - 1, 1, statusWindowWidth - 1,
+		statusWindowHeight - 3);
+	JXDrawLine(display, statusWindow, rootGC,
+		statusWindowWidth - 2, 2, statusWindowWidth - 2,
+		statusWindowHeight - 3);
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void DestroyMoveResizeWindow() {
+
+	if(statusWindow != None) {
+		JXDestroyWindow(display, statusWindow);
+		statusWindow = None;
+	}
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void CreateMoveWindow(ClientNode *np) {
+
+	CreateMoveResizeWindow(np, moveStatusType);
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void UpdateMoveWindow(ClientNode *np) {
+
+	char str[80];
+	unsigned int width;
+
+	if(moveStatusType == SW_OFF) {
+		return;
+	}
+
+	DrawMoveResizeWindow(np, moveStatusType);
+
+	snprintf(str, sizeof(str), "(%d, %d)", np->x, np->y);
+	width = GetStringWidth(FONT_MENU, str);
+	RenderString(statusWindow, FONT_MENU, COLOR_MENU_FG,
+		statusWindowWidth / 2 - width / 2, 4, rootWidth, NULL, str);
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void DestroyMoveWindow() {
+
+	DestroyMoveResizeWindow();
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void CreateResizeWindow(ClientNode *np) {
+
+	CreateMoveResizeWindow(np, resizeStatusType);
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void UpdateResizeWindow(ClientNode *np, int gwidth, int gheight) {
+
+	char str[80];
+	unsigned int fontWidth;
+
+	if(resizeStatusType == SW_OFF) {
+		return;
+	}
+
+	DrawMoveResizeWindow(np, resizeStatusType);
+
+	snprintf(str, sizeof(str), "%d x %d", gwidth, gheight);
+	fontWidth = GetStringWidth(FONT_MENU, str);
+	RenderString(statusWindow, FONT_MENU, COLOR_MENU_FG,
+		statusWindowWidth / 2 - fontWidth / 2, 4, rootWidth, NULL, str);
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void DestroyResizeWindow() {
+
+	DestroyMoveResizeWindow();
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+StatusWindowType ParseType(const char *str) {
+
+	if(!str) {
+		return SW_SCREEN;
+	} else if(!strcmp(str, "off")) {
+		return SW_OFF;
+	} else if(!strcmp(str, "screen")) {
+		return SW_SCREEN;
+	} else if(!strcmp(str, "window")) {
+		return SW_WINDOW;
+	} else if(!strcmp(str, "corner")) {
+		return SW_CORNER;
+	} else {
+		return SW_INVALID;
+	}
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void SetMoveStatusType(const char *str) {
+
+	StatusWindowType type;
+
+	type = ParseType(str);
+	if(type == SW_INVALID) {
+		moveStatusType = SW_SCREEN;
+		Warning("invalid MoveMode coordinates: \"%s\"", str);
+	} else {
+		moveStatusType = type;
+	}
+
+}
+
+/*************************************************************************
+ *************************************************************************/
+void SetResizeStatusType(const char *str) {
+
+	StatusWindowType type;
+
+	type = ParseType(str);
+	if(type == SW_INVALID) {
+		resizeStatusType = SW_SCREEN;
+		Warning("invalid ResizeMode coordinates: \"%s\"", str);
+	} else {
+		resizeStatusType = type;
+	}
+
+}
+
diff --git a/src/status.h b/src/status.h
new file mode 100644
index 0000000..9fcabb8
--- /dev/null
+++ b/src/status.h
@@ -0,0 +1,55 @@
+/**
+ * @file status.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the status functions.
+ *
+ */
+
+#ifndef STATUS_H
+#define STATUS_H
+
+struct ClientNode;
+
+/** Create a move status window.
+ * @param np The client to be moved.
+ */
+void CreateMoveWindow(struct ClientNode *np);
+
+/** Update a move status window.
+ * @param np The client being moved.
+ */
+void UpdateMoveWindow(struct ClientNode *np);
+
+/** Destroy a move status window. */
+void DestroyMoveWindow();
+
+/** Create a resize status window.
+ * @param np The client being resized.
+ */
+void CreateResizeWindow(struct ClientNode *np);
+
+/** Update a resize status window.
+ * @param np The client being resized.
+ * @param gwidth The width to display.
+ * @param gheight The height to display.
+ */
+void UpdateResizeWindow(struct ClientNode *np, int gwidth, int gheight);
+
+/** Destroy a resize status window. */
+void DestroyResizeWindow();
+
+/** Set the location of move status windows.
+ * @param str The location (off, screen, window, or corner).
+ */
+void SetMoveStatusType(const char *str);
+
+/** Set the location of resize status windows.
+ * @param str The location (off, screen, window, or corner).
+ */
+void SetResizeStatusType(const char *str);
+
+#endif
+
+
diff --git a/src/swallow.c b/src/swallow.c
new file mode 100644
index 0000000..26836f1
--- /dev/null
+++ b/src/swallow.c
@@ -0,0 +1,274 @@
+/**
+ * @file swallow.c
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Swallow tray component.
+ *
+ */
+
+#include "jwm.h"
+#include "swallow.h"
+#include "main.h"
+#include "tray.h"
+#include "error.h"
+#include "root.h"
+#include "color.h"
+#include "client.h"
+#include "event.h"
+#include "misc.h"
+
+typedef struct SwallowNode {
+
+	TrayComponentType *cp;
+
+	char *name;
+	char *command;
+	int border;
+	int userWidth;
+	int userHeight;
+
+	struct SwallowNode *next;
+
+} SwallowNode;
+
+static SwallowNode *swallowNodes;
+
+static void Destroy(TrayComponentType *cp);
+static void Resize(TrayComponentType *cp);
+
+/** Initialize swallow data. */
+void InitializeSwallow() {
+	swallowNodes = NULL;
+}
+
+/** Start swallow processing. */
+void StartupSwallow() {
+
+	SwallowNode *np;
+
+	for(np = swallowNodes; np; np = np->next) {
+		if(np->command) {
+			RunCommand(np->command);
+		}
+	}
+
+}
+
+/** Stop swallow processing. */
+void ShutdownSwallow() {
+}
+
+/** Destroy swallow data. */
+void DestroySwallow() {
+
+	SwallowNode *np;
+
+	while(swallowNodes) {
+
+		np = swallowNodes->next;
+
+		Assert(swallowNodes->name);
+		Release(swallowNodes->name);
+
+		if(swallowNodes->command) {
+			Release(swallowNodes->command);
+		}
+
+		Release(swallowNodes);
+		swallowNodes = np;
+
+	}
+
+}
+
+/** Create a swallowed application tray component. */
+TrayComponentType *CreateSwallow(const char *name, const char *command,
+	int width, int height) {
+
+	TrayComponentType *cp;
+	SwallowNode *np;
+
+	if(!name) {
+		Warning("cannot swallow a client with no name");
+		return NULL;
+	}
+
+	/* Make sure this name isn't already used. */
+	for(np = swallowNodes; np; np = np->next) {
+		if(!strcmp(np->name, name)) {
+			Warning("cannot swallow the same client multiple times");
+			return NULL;
+		}
+	}
+
+	np = Allocate(sizeof(SwallowNode));
+	np->name = CopyString(name);
+	np->command = CopyString(command);
+
+	np->next = swallowNodes;
+	swallowNodes = np;
+
+	cp = CreateTrayComponent();
+	np->cp = cp;
+	cp->object = np;
+	cp->Destroy = Destroy;
+	cp->Resize = Resize;
+
+	if(width) {
+		cp->requestedWidth = width;
+		np->userWidth = 1;
+	} else {
+		cp->requestedWidth = 1;
+		np->userWidth = 0;
+	}
+	if(height) {
+		cp->requestedHeight = height;
+		np->userHeight = 1;
+	} else {
+		cp->requestedHeight = 1;
+		np->userHeight = 0;
+	}
+
+	return cp;
+
+}
+
+/** Process an event on a swallowed window. */
+int ProcessSwallowEvent(const XEvent *event) {
+
+	SwallowNode *np;
+	int width, height;
+
+	for(np = swallowNodes; np; np = np->next) {
+		if(event->xany.window == np->cp->window) {
+			switch(event->type) {
+			case DestroyNotify:
+				np->cp->window = None;
+				np->cp->requestedWidth = 1;
+				np->cp->requestedHeight = 1;
+				ResizeTray(np->cp->tray);
+				break;
+			case ResizeRequest:
+				np->cp->requestedWidth
+					= event->xresizerequest.width + np->border * 2;
+				np->cp->requestedHeight
+					= event->xresizerequest.height + np->border * 2;
+				ResizeTray(np->cp->tray);
+				break;
+			case ConfigureNotify:
+				/* I don't think this should be necessary, but somehow
+				 * resize requests slip by sometimes... */
+				width = event->xconfigure.width + np->border * 2;
+				height = event->xconfigure.height + np->border * 2;
+				if(   width != np->cp->requestedWidth
+					&& height != np->cp->requestedHeight) {
+					np->cp->requestedWidth = width;
+					np->cp->requestedHeight = height;
+					ResizeTray(np->cp->tray);
+				}
+				break;
+			default:
+				break;
+			}
+			return 1;
+		}
+	}
+
+	return 0;
+
+}
+
+/** Handle a tray resize. */
+void Resize(TrayComponentType *cp) {
+
+	int width, height;
+
+	SwallowNode *np = (SwallowNode*)cp->object;
+
+	if(cp->window != None) {
+
+		width = cp->width - np->border * 2;
+		height = cp->height - np->border * 2;
+
+		JXResizeWindow(display, cp->window, width, height);
+
+	}
+
+}
+
+/** Destroy a swallow tray component. */
+void Destroy(TrayComponentType *cp) {
+
+	ClientProtocolType protocols;
+
+	if(cp->window) {
+
+		JXReparentWindow(display, cp->window, rootWindow, 0, 0);
+		JXRemoveFromSaveSet(display, cp->window);
+
+		protocols = ReadWMProtocols(cp->window);
+		if(protocols & PROT_DELETE) {
+			SendClientMessage(cp->window, ATOM_WM_PROTOCOLS,
+				ATOM_WM_DELETE_WINDOW);
+		} else {
+			JXKillClient(display, cp->window);
+		}
+
+	}
+
+}
+
+/** Determine if this is a window to be swallowed, if it is, swallow it. */
+int CheckSwallowMap(const XMapEvent *event) {
+
+	SwallowNode *np;
+	XClassHint hint;
+	XWindowAttributes attr;
+
+	for(np = swallowNodes; np; np = np->next) {
+
+		if(np->cp->window != None) {
+			continue;
+		}
+
+		Assert(np->cp->tray->window != None);
+
+		if(JXGetClassHint(display, event->window, &hint)) {
+			if(!strcmp(hint.res_name, np->name)) {
+
+				/* Swallow the window. */
+				JXSelectInput(display, event->window,
+					  StructureNotifyMask | ResizeRedirectMask);
+				JXAddToSaveSet(display, event->window);
+				JXSetWindowBorder(display, event->window, colors[COLOR_TRAY_BG]);
+				JXReparentWindow(display, event->window,
+					np->cp->tray->window, 0, 0);
+				JXMapRaised(display, event->window);
+				JXFree(hint.res_name);
+				JXFree(hint.res_class);
+				np->cp->window = event->window;
+
+				/* Update the size. */
+				JXGetWindowAttributes(display, event->window, &attr);
+				np->border = attr.border_width;
+				if(!np->userWidth) {
+					np->cp->requestedWidth = attr.width + 2 * np->border;
+				}
+				if(!np->userHeight) {
+					np->cp->requestedHeight = attr.height + 2 * np->border;
+				}
+
+				ResizeTray(np->cp->tray);
+
+				return 1;
+
+			}
+		}
+
+	}
+
+	return 0;
+
+}
+
diff --git a/src/swallow.h b/src/swallow.h
new file mode 100644
index 0000000..148bea6
--- /dev/null
+++ b/src/swallow.h
@@ -0,0 +1,43 @@
+/**
+ * @file swallow.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Swallow tray component.
+ *
+ */
+
+#ifndef SWALLOW_H
+#define SWALLOW_H
+
+/*@{*/
+void InitializeSwallow();
+void StartupSwallow();
+void ShutdownSwallow();
+void DestroySwallow();
+/*@}*/
+
+/** Create a swallowed application tray component.
+ * @param name The name of the application to swallow.
+ * @param command The command used to start the swallowed application.
+ * @param width The width to use (0 for default).
+ * @param height the height to use (0 for default).
+ */
+struct TrayComponentType *CreateSwallow(
+	const char *name, const char *command,
+	int width, int height);
+
+/** Determine if a map event was for a window that should be swallowed.
+ * @param event The map event.
+ * @return 1 if this window should be swallowed, 0 if not.
+ */
+int CheckSwallowMap(const XMapEvent *event);
+
+/** Process an event on a swallowed window.
+ * @param event The event to process.
+ * @return 1 if the event was for a swallowed window, 0 if not.
+ */
+int ProcessSwallowEvent(const XEvent *event);
+
+#endif
+
diff --git a/src/taskbar.c b/src/taskbar.c
new file mode 100644
index 0000000..f8ab13c
--- /dev/null
+++ b/src/taskbar.c
@@ -0,0 +1,936 @@
+/***************************************************************************
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "taskbar.h"
+#include "tray.h"
+#include "timing.h"
+#include "main.h"
+#include "client.h"
+#include "color.h"
+#include "popup.h"
+#include "button.h"
+#include "cursor.h"
+#include "icon.h"
+#include "error.h"
+#include "font.h"
+#include "winmenu.h"
+#include "screen.h"
+
+typedef enum {
+	INSERT_LEFT,
+	INSERT_RIGHT
+} InsertModeType;
+
+typedef struct TaskBarType {
+
+	TrayComponentType *cp;
+
+	int itemHeight;
+	LayoutType layout;
+
+	Pixmap buffer;
+
+	TimeType mouseTime;
+	int mousex, mousey;
+
+	unsigned int maxItemWidth;
+
+	struct TaskBarType *next;
+
+} TaskBarType;
+
+typedef struct Node {
+	ClientNode *client;
+	int y;
+	struct Node *next;
+	struct Node *prev;
+} Node;
+
+static char minimized_bitmap[] = {
+	0x01, 0x03,
+	0x07, 0x0F
+};
+
+static const int TASK_SPACER = 2;
+
+static Pixmap minimizedPixmap;
+static InsertModeType insertMode;
+
+static TaskBarType *bars;
+static Node *taskBarNodes;
+static Node *taskBarNodesTail;
+
+static Node *GetNode(TaskBarType *bar, int x);
+static unsigned int GetItemCount();
+static int ShouldShowItem(const ClientNode *np);
+static int ShouldFocusItem(const ClientNode *np);
+static unsigned int GetItemWidth(const TaskBarType *bp,
+	unsigned int itemCount);
+static void Render(const TaskBarType *bp);
+static void ShowTaskWindowMenu(TaskBarType *bar, Node *np);
+
+static void SetSize(TrayComponentType *cp, int width, int height);
+static void Create(TrayComponentType *cp);
+static void Destroy(TrayComponentType *cp);
+static void Resize(TrayComponentType *cp);
+static void ProcessTaskButtonEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+static void ProcessTaskMotionEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeTaskBar() {
+	bars = NULL;
+	taskBarNodes = NULL;
+	taskBarNodesTail = NULL;
+	insertMode = INSERT_RIGHT;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void StartupTaskBar() {
+	minimizedPixmap = JXCreatePixmapFromBitmapData(display, rootWindow,
+		minimized_bitmap, 4, 4, colors[COLOR_TASK_FG],
+		colors[COLOR_TASK_BG], rootDepth);
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShutdownTaskBar() {
+
+	TaskBarType *bp;
+
+	for(bp = bars; bp; bp = bp->next) {
+		JXFreePixmap(display, bp->buffer);
+	}
+
+	JXFreePixmap(display, minimizedPixmap);
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyTaskBar() {
+
+	TaskBarType *bp;
+
+	while(bars) {
+		bp = bars->next;
+		Release(bars);
+		bars = bp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+TrayComponentType *CreateTaskBar() {
+
+	TrayComponentType *cp;
+	TaskBarType *tp;
+
+	tp = Allocate(sizeof(TaskBarType));
+	tp->next = bars;
+	bars = tp;
+	tp->itemHeight = 0;
+	tp->layout = LAYOUT_HORIZONTAL;
+	tp->mousex = -1;
+	tp->mousey = -1;
+	tp->mouseTime.seconds = 0;
+	tp->mouseTime.ms = 0;
+	tp->maxItemWidth = 0;
+
+	cp = CreateTrayComponent();
+	cp->object = tp;
+	tp->cp = cp;
+
+	cp->SetSize = SetSize;
+	cp->Create = Create;
+	cp->Destroy = Destroy;
+	cp->Resize = Resize;
+	cp->ProcessButtonEvent = ProcessTaskButtonEvent;
+	cp->ProcessMotionEvent = ProcessTaskMotionEvent;
+
+	return cp;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetSize(TrayComponentType *cp, int width, int height) {
+
+	TaskBarType *tp;
+
+	Assert(cp);
+
+	tp = (TaskBarType*)cp->object;
+
+	Assert(tp);
+
+	if(width == 0) {
+		tp->layout = LAYOUT_HORIZONTAL;
+	} else if(height == 0) {
+		tp->layout = LAYOUT_VERTICAL;
+	} else if(width > height) {
+		tp->layout = LAYOUT_HORIZONTAL;
+	} else {
+		tp->layout = LAYOUT_VERTICAL;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Create(TrayComponentType *cp) {
+
+	TaskBarType *tp;
+
+	Assert(cp);
+
+	tp = (TaskBarType*)cp->object;
+
+	Assert(tp);
+
+	if(tp->layout == LAYOUT_HORIZONTAL) {
+		tp->itemHeight = cp->height - TASK_SPACER;
+	} else {
+		tp->itemHeight = GetStringHeight(FONT_TASK) + 12;
+	}
+
+	Assert(cp->width > 0);
+	Assert(cp->height > 0);
+
+	cp->pixmap = JXCreatePixmap(display, rootWindow, cp->width, cp->height,
+		rootDepth);
+	tp->buffer = cp->pixmap;
+
+	JXSetForeground(display, rootGC, colors[COLOR_TASK_BG]);
+	JXFillRectangle(display, cp->pixmap, rootGC, 0, 0, cp->width, cp->height);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Resize(TrayComponentType *cp) {
+
+	TaskBarType *tp;
+
+	Assert(cp);
+
+	tp = (TaskBarType*)cp->object;
+
+	Assert(tp);
+
+	if(tp->buffer != None) {
+		JXFreePixmap(display, tp->buffer);
+	}
+
+	if(tp->layout == LAYOUT_HORIZONTAL) {
+		tp->itemHeight = cp->height - TASK_SPACER;
+	} else {
+		tp->itemHeight = GetStringHeight(FONT_TASK) + 12;
+	}
+
+	Assert(cp->width > 0);
+	Assert(cp->height > 0);
+
+	cp->pixmap = JXCreatePixmap(display, rootWindow, cp->width, cp->height,
+		rootDepth);
+	tp->buffer = cp->pixmap;
+
+	JXSetForeground(display, rootGC, colors[COLOR_TASK_BG]);
+	JXFillRectangle(display, cp->pixmap, rootGC,
+		0, 0, cp->width, cp->height);
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Destroy(TrayComponentType *cp) {
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ProcessTaskButtonEvent(TrayComponentType *cp, int x, int y, int mask) {
+
+	TaskBarType *bar = (TaskBarType*)cp->object;
+	Node *np;
+
+	Assert(bar);
+
+	if(bar->layout == LAYOUT_HORIZONTAL) {
+		np = GetNode(bar, x);
+	} else {
+		np = GetNode(bar, y);
+	}
+
+	if(np) {
+		switch(mask) {
+		case Button1:
+			if(np->client->state.status & STAT_ACTIVE
+				&& np->client == nodes[np->client->state.layer]) {
+				MinimizeClient(np->client);
+			} else {
+				RestoreClient(np->client, 1);
+				FocusClient(np->client);
+			}
+			break;
+		case Button3:
+			ShowTaskWindowMenu(bar, np);
+			break;
+		case Button4:
+			FocusPrevious();
+			break;
+		case Button5:
+			FocusNext();
+			break;
+		default:
+			break;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ProcessTaskMotionEvent(TrayComponentType *cp, int x, int y, int mask) {
+
+	TaskBarType *bp = (TaskBarType*)cp->object;
+
+	bp->mousex = cp->screenx + x;
+	bp->mousey = cp->screeny + y;
+	GetCurrentTime(&bp->mouseTime);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShowTaskWindowMenu(TaskBarType *bar, Node *np) {
+
+	int x, y;
+	int mwidth, mheight;
+	const ScreenType *sp;
+
+	GetWindowMenuSize(np->client, &mwidth, &mheight);
+
+	sp = GetCurrentScreen(x, y);
+
+	if(bar->layout == LAYOUT_HORIZONTAL) {
+		GetMousePosition(&x, &y);
+		if(bar->cp->screeny + bar->cp->height / 2 < sp->y + sp->height / 2) {
+			y = bar->cp->screeny + bar->cp->height;
+		} else {
+			y = bar->cp->screeny - mheight;
+		}
+		x -= mwidth / 2;
+	} else {
+		if(bar->cp->screenx + bar->cp->width / 2 < sp->x + sp->width / 2) {
+			x = bar->cp->screenx + bar->cp->width;
+		} else {
+			x = bar->cp->screenx - mwidth;
+		}
+		y = bar->cp->screeny + np->y;
+	}
+
+	ShowWindowMenu(np->client, x, y);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void AddClientToTaskBar(ClientNode *np) {
+
+	Node *tp;
+
+	Assert(np);
+
+	tp = Allocate(sizeof(Node));
+	tp->client = np;
+
+	if(insertMode == INSERT_RIGHT) {
+		tp->next = NULL;
+		tp->prev = taskBarNodesTail;
+		if(taskBarNodesTail) {
+			taskBarNodesTail->next = tp;
+		} else {
+			taskBarNodes = tp;
+		}
+		taskBarNodesTail = tp;
+	} else {
+		tp->prev = NULL;
+		tp->next = taskBarNodes;
+		if(taskBarNodes) {
+			taskBarNodes->prev = tp;
+		}
+		taskBarNodes = tp;
+		if(!taskBarNodesTail) {
+			taskBarNodesTail = tp;
+		}
+	}
+
+	UpdateTaskBar();
+
+	UpdateNetClientList();
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void RemoveClientFromTaskBar(ClientNode *np) {
+
+	Node *tp;
+
+	Assert(np);
+
+	for(tp = taskBarNodes; tp; tp = tp->next) {
+		if(tp->client == np) {
+			if(tp->prev) {
+				tp->prev->next = tp->next;
+			} else {
+				taskBarNodes = tp->next;
+			}
+			if(tp->next) {
+				tp->next->prev = tp->prev;
+			} else {
+				taskBarNodesTail = tp->prev;
+			}
+			Release(tp);
+			break;
+		}
+	}
+
+	UpdateTaskBar();
+
+	UpdateNetClientList();
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void UpdateTaskBar() {
+
+	TaskBarType *bp;
+	unsigned int count;
+	int lastHeight;
+
+	if(shouldExit) {
+		return;
+	}
+
+	for(bp = bars; bp; bp = bp->next) {
+
+		if(bp->layout == LAYOUT_VERTICAL) {
+			lastHeight = bp->cp->requestedHeight;
+			count = GetItemCount();
+			bp->cp->requestedHeight = GetStringHeight(FONT_TASK) + 12;
+			bp->cp->requestedHeight *= count;
+			bp->cp->requestedHeight += 2;
+			if(lastHeight != bp->cp->requestedHeight) {
+				ResizeTray(bp->cp->tray);
+			}
+		}
+
+		Render(bp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SignalTaskbar(const TimeType *now, int x, int y) {
+
+	TaskBarType *bp;
+	Node *np;
+
+	for(bp = bars; bp; bp = bp->next) {
+		if(abs(bp->mousex - x) < POPUP_DELTA
+			&& abs(bp->mousey - y) < POPUP_DELTA) {
+			if(GetTimeDifference(now, &bp->mouseTime) >= popupDelay) {
+				if(bp->layout == LAYOUT_HORIZONTAL) {
+					np = GetNode(bp, x - bp->cp->screenx);
+				} else {
+					np = GetNode(bp, y - bp->cp->screeny);
+				}
+				if(np) {
+					ShowPopup(x, y, np->client->name);
+				}
+			}
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Render(const TaskBarType *bp) {
+
+	Node *tp;
+	ButtonNode button;
+	int x, y;
+	int remainder;
+	int itemWidth, itemCount;
+	int width, height;
+	int iconSize;
+	Pixmap buffer;
+	GC gc;
+	char *minimizedName;
+
+	if(shouldExit) {
+		return;
+	}
+
+	Assert(bp);
+	Assert(bp->cp);
+
+	width = bp->cp->width;
+	height = bp->cp->height;
+	buffer = bp->cp->pixmap;
+	gc = rootGC;
+
+	x = TASK_SPACER;
+	width -= x;
+	y = 1;
+
+	JXSetForeground(display, gc, colors[COLOR_TASK_BG]);
+	JXFillRectangle(display, buffer, gc, 0, 0, width, height);
+
+	itemCount = GetItemCount();
+	if(!itemCount) {
+		UpdateSpecificTray(bp->cp->tray, bp->cp);
+		return;
+	}
+	if(bp->layout == LAYOUT_HORIZONTAL) {
+		itemWidth = GetItemWidth(bp, itemCount);
+		remainder = width - itemWidth * itemCount;
+	} else {
+		itemWidth = width;
+		remainder = 0;
+	}
+
+	iconSize = bp->itemHeight - 2 * TASK_SPACER - 4;
+
+	ResetButton(&button, buffer, gc);
+	button.font = FONT_TASK;
+
+	for(tp = taskBarNodes; tp; tp = tp->next) {
+		if(ShouldShowItem(tp->client)) {
+
+			tp->y = y;
+
+			if(tp->client->state.status & STAT_ACTIVE) {
+				button.type = BUTTON_TASK_ACTIVE;
+			} else {
+				button.type = BUTTON_TASK;
+			}
+
+			if(remainder) {
+				button.width = itemWidth - TASK_SPACER;
+			} else {
+				button.width = itemWidth - TASK_SPACER - 1;
+			}
+			button.height = bp->itemHeight - 1;
+			button.x = x;
+			button.y = y;
+			button.icon = tp->client->icon;
+
+			if(tp->client->state.status & STAT_MINIMIZED) {
+				minimizedName = AllocateStack(strlen(tp->client->name) + 3);
+				sprintf(minimizedName, "[%s]", tp->client->name);
+				button.text = minimizedName;
+				DrawButton(&button);
+				ReleaseStack(minimizedName);
+			} else {
+				button.text = tp->client->name;
+				DrawButton(&button);
+			}
+
+			if(tp->client->state.status & STAT_MINIMIZED) {
+				JXCopyArea(display, minimizedPixmap, buffer, gc,
+					0, 0, 4, 4, x + 3, y + bp->itemHeight - 7);
+			}
+
+			if(bp->layout == LAYOUT_HORIZONTAL) {
+				x += itemWidth;
+				if(remainder) {
+					++x;
+					--remainder;
+				}
+			} else {
+				y += bp->itemHeight;
+				if(remainder) {
+					++y;
+					--remainder;
+				}
+			}
+
+		}
+	}
+
+	UpdateSpecificTray(bp->cp->tray, bp->cp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void FocusNext() {
+
+	Node *tp;
+
+	for(tp = taskBarNodes; tp; tp = tp->next) {
+		if(ShouldFocusItem(tp->client)) {
+			if(tp->client->state.status & STAT_ACTIVE) {
+				tp = tp->next;
+				break;
+			}
+		}
+	}
+
+	if(!tp) {
+		tp = taskBarNodes;
+	}
+
+	while(tp && !ShouldFocusItem(tp->client)) {
+		tp = tp->next;
+	}
+
+	if(!tp) {
+		tp = taskBarNodes;
+		while(tp && !ShouldFocusItem(tp->client)) {
+			tp = tp->next;
+		}
+	}
+
+	if(tp) {
+		RestoreClient(tp->client, 1);
+		FocusClient(tp->client);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void FocusPrevious() {
+
+	Node *tp;
+
+	for(tp = taskBarNodesTail; tp; tp = tp->prev) {
+		if(ShouldFocusItem(tp->client)) {
+			if(tp->client->state.status & STAT_ACTIVE) {
+				tp = tp->prev;
+				break;
+			}
+		}
+	}
+
+	if(!tp) {
+		tp = taskBarNodesTail;
+	}
+
+	while(tp && !ShouldFocusItem(tp->client)) {
+		tp = tp->prev;
+	}
+
+	if(!tp) {
+		tp = taskBarNodesTail;
+		while(tp && !ShouldFocusItem(tp->client)) {
+			tp = tp->prev;
+		}
+	}
+
+	if(tp) {
+		RestoreClient(tp->client, 1);
+		FocusClient(tp->client);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void FocusNextStackedCircular() {
+
+	ClientNode *ac;
+	ClientNode *np;
+	int x;
+
+	ac = GetActiveClient();
+	np = NULL;
+
+	/* Check for a valid client below this client in the same layer. */
+	if(ac) {
+		for(np = ac->next; np; np = np->next) {
+			if(ShouldFocusItem(np)) {
+				break;
+			}
+		}
+	}
+
+	/* Check for a valid client in lower layers. */
+	if(ac && !np) {
+		for(x = ac->state.layer - 1; x >= LAYER_BOTTOM; x--) {
+			for(np = nodes[x]; np; np = np->next) {
+				if(ShouldFocusItem(np)) {
+					break;
+				}
+			}
+			if(np) {
+				break;
+			}
+		}
+	}
+
+	/* Revert to the top-most valid client. */
+	if(!np) {
+		for(x = LAYER_TOP; x >= LAYER_BOTTOM; x--) {
+			for(np = nodes[x]; np; np = np->next) {
+				if(ShouldFocusItem(np)) {
+					break;
+				}
+			}
+			if(np) {
+				break;
+			}
+		}
+	}
+
+	if(np) {
+		FocusClient(np);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+Node *GetNode(TaskBarType *bar, int x) {
+
+	Node *tp;
+	int remainder;
+	int itemCount;
+	int itemWidth;
+	int index, stop;
+	int width;
+
+	index = TASK_SPACER;
+
+	itemCount = GetItemCount();
+
+	if(bar->layout == LAYOUT_HORIZONTAL) {
+
+		width = bar->cp->width - index; 
+		itemWidth = GetItemWidth(bar, itemCount);
+		remainder = width - itemWidth * itemCount;
+
+		for(tp = taskBarNodes; tp; tp = tp->next) {
+			if(ShouldShowItem(tp->client)) {
+				if(remainder) {
+					stop = index + itemWidth + 1;
+					--remainder;
+				} else {
+					stop = index + itemWidth;
+				}
+				if(x >= index && x < stop) {
+					return tp;
+				}
+				index = stop;
+			}
+		}
+
+	} else {
+
+		for(tp = taskBarNodes; tp; tp = tp->next) {
+			if(ShouldShowItem(tp->client)) {
+				stop = index + bar->itemHeight;
+				if(x >= index && x < stop) {
+					return tp;
+				}
+				index = stop;
+			}
+		}
+
+	}
+
+	return NULL;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+unsigned int GetItemCount() {
+
+	Node *tp;
+	unsigned int count;
+
+	count = 0;
+	for(tp = taskBarNodes; tp; tp = tp->next) {
+		if(ShouldShowItem(tp->client)) {
+			++count;
+		}
+	}
+
+	return count;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ShouldShowItem(const ClientNode *np) {
+
+	if(np->state.desktop != currentDesktop
+		&& !(np->state.status & STAT_STICKY)) {
+		return 0;
+	}
+
+	if(np->state.status & STAT_NOLIST) {
+		return 0;
+	}
+
+	if(np->owner != None) {
+		return 0;
+	}
+
+	if(!(np->state.status & STAT_MAPPED)
+		&& !(np->state.status & (STAT_MINIMIZED | STAT_SHADED))) {
+		return 0;
+	}
+
+	return 1;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ShouldFocusItem(const ClientNode *np) {
+
+	if(np->state.desktop != currentDesktop
+		&& !(np->state.status & STAT_STICKY)) {
+		return 0;
+	}
+
+	if(np->state.status & STAT_NOLIST) {
+		return 0;
+	}
+
+	if(!(np->state.status & STAT_MAPPED)) {
+		return 0;
+	}
+
+	if(np->owner != None) {
+		return 0;
+	}
+
+	return 1;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+unsigned int GetItemWidth(const TaskBarType *bp, unsigned int itemCount) {
+
+	unsigned int itemWidth;
+
+	itemWidth = bp->cp->width - TASK_SPACER;
+
+	if(!itemCount) {
+		return itemWidth;
+	}
+
+	itemWidth /= itemCount;
+	if(!itemWidth) {
+		itemWidth = 1;
+	}
+
+	if(bp->maxItemWidth > 0 && itemWidth > bp->maxItemWidth) {
+		itemWidth = bp->maxItemWidth;
+	}
+
+	return itemWidth;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetMaxTaskBarItemWidth(TrayComponentType *cp, const char *value) {
+
+	int temp;
+	TaskBarType *bp;
+
+	Assert(cp);
+
+	if(value) {
+		temp = atoi(value);
+		if(temp < 0) {
+			Warning("invalid maxwidth for TaskList: %s", value);
+			return;
+		}
+		bp = (TaskBarType*)cp->object;
+		bp->maxItemWidth = temp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTaskBarInsertMode(const char *mode) {
+
+	if(!mode) {
+		insertMode = INSERT_RIGHT;
+		return;
+	}
+
+	if(!strcmp(mode, "right")) {
+		insertMode = INSERT_RIGHT;
+	} else if(!strcmp(mode, "left")) {
+		insertMode = INSERT_LEFT;
+	} else {
+		Warning("invalid insert mode: \"%s\"", mode);
+		insertMode = INSERT_RIGHT;
+	}
+
+}
+
+/***************************************************************************
+ * Maintain the _NET_CLIENT_LIST[_STACKING] properties on the root window.
+ ***************************************************************************/
+void UpdateNetClientList() {
+
+	Node *np;
+	ClientNode *client;
+	Window *windows;
+	int count;
+	int layer;
+
+	count = 0;
+	for(np = taskBarNodes; np; np = np->next) {
+		++count;
+	}
+
+	if(count == 0) {
+		windows = NULL;
+	} else {
+		windows = AllocateStack(count * sizeof(Window));
+	}
+
+	/* Set _NET_CLIENT_LIST */
+	count = 0;
+	for(np = taskBarNodes; np; np = np->next) {
+		windows[count++] = np->client->window;
+	}
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_CLIENT_LIST],
+		XA_WINDOW, 32, PropModeReplace, (unsigned char*)windows, count);
+
+	/* Set _NET_CLIENT_LIST_STACKING */
+	count = 0;
+	for(layer = LAYER_BOTTOM; layer <= LAYER_TOP; layer++) {
+		for(client = nodes[layer]; client; client = client->next) {
+			windows[count++] = client->window;
+		}
+	}
+	JXChangeProperty(display, rootWindow, atoms[ATOM_NET_CLIENT_LIST_STACKING],
+		XA_WINDOW, 32, PropModeReplace, (unsigned char*)windows, count);
+
+	if(windows != NULL) {
+		ReleaseStack(windows);
+	}
+	
+}
+
diff --git a/src/taskbar.h b/src/taskbar.h
new file mode 100644
index 0000000..e65600f
--- /dev/null
+++ b/src/taskbar.h
@@ -0,0 +1,64 @@
+/**
+ * @file taskbar.h
+ * @author Joe Wingbermuehle
+ * @date 2005-2006
+ *
+ * @brief Task list tray component.
+ *
+ */
+
+#ifndef TASKBAR_H
+#define TASKBAR_H
+
+struct ClientNode;
+struct TimeType;
+
+/*@{*/
+void InitializeTaskBar();
+void StartupTaskBar();
+void ShutdownTaskBar();
+void DestroyTaskBar();
+/*@}*/
+
+/** Create a new task bar tray component. */
+struct TrayComponentType *CreateTaskBar();
+
+/** Add a client to the task bar(s).
+ * @param np The client to add.
+ */
+void AddClientToTaskBar(struct ClientNode *np);
+
+/** Remove a client from the task bar(s).
+ * @param np The client to remove.
+ */
+void RemoveClientFromTaskBar(struct ClientNode *np);
+
+void UpdateTaskBar();
+
+void SignalTaskbar(const struct TimeType *now, int x, int y);
+
+/** Focus the next client in the task bar. */
+void FocusNext();
+
+/** Focus the previous client in the task bar. */
+void FocusPrevious();
+
+/** Focus the next stacked client. */
+void FocusNextStackedCircular();
+
+/** Set the maximum width of task bar items.
+ * @param cp The task bar component.
+ * @param value The maximum width.
+ */
+void SetMaxTaskBarItemWidth(struct TrayComponentType *cp, const char *value);
+
+/** Set the insertion mode for task bars.
+ * @param mode The insertion mode (either right or left).
+ */
+void SetTaskBarInsertMode(const char *mode);
+
+/** Update the _NET_CLIENT_LIST property. */
+void UpdateNetClientList();
+
+#endif
+
diff --git a/src/theme.c b/src/theme.c
new file mode 100644
index 0000000..4560abc
--- /dev/null
+++ b/src/theme.c
@@ -0,0 +1,88 @@
+/****************************************************************************
+ * Theme functions.
+ * Copyright (C) 2006 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "theme.h"
+#include "error.h"
+#include "misc.h"
+
+typedef struct ThemePathNode {
+	char *path;
+	struct ThemePathNode *next;
+} ThemePathNode;
+
+static ThemePathNode *themePaths;
+static char *themeName;
+
+/****************************************************************************
+ ****************************************************************************/
+void InitializeThemes() {
+
+	themeName = NULL;
+	themePaths = NULL;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void StartupThemes() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShutdownThemes() {
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void DestroyThemes() {
+
+	ThemePathNode *tp;
+
+	if(themeName) {
+		Release(themeName);
+	}
+
+	while(themePaths) {
+		tp = themePaths->next;
+		Release(themePaths->path);
+		Release(themePaths);
+		themePaths = tp;
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddThemePath(const char *path) {
+
+	ThemePathNode *tp;
+
+	if(!path) {
+		return;
+	}
+
+	tp = Allocate(sizeof(ThemePathNode));
+	tp->path = CopyString(path);
+	Trim(tp->path);
+
+	tp->next = themePaths;
+	themePaths = tp;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void SetTheme(const char *name) {
+
+	if(themeName) {
+		Warning("theme set multiple times");
+	}
+
+	themeName = CopyString(name);
+	Trim(themeName);
+
+}
+
diff --git a/src/theme.h b/src/theme.h
new file mode 100644
index 0000000..2dd1400
--- /dev/null
+++ b/src/theme.h
@@ -0,0 +1,31 @@
+/**
+ * @file theme.h
+ * @author Joe Wingbermuehle
+ * @date 2006
+ *
+ * @brief Header for the theme functions.
+ *
+ */
+
+#ifndef THEME_H
+#define THEME_H
+
+/*@{*/
+void InitializeThemes();
+void StartupThemes();
+void ShutdownThemes();
+void DestroyThemes();
+/*@}*/
+
+/** Add a theme path.
+ * @param path The path to add.
+ */
+void AddThemePath(const char *path);
+
+/** Set the theme to use.
+ * @param name The name of the theme.
+ */
+void SetTheme(const char *name);
+
+#endif
+
diff --git a/src/timing.c b/src/timing.c
new file mode 100644
index 0000000..047d919
--- /dev/null
+++ b/src/timing.c
@@ -0,0 +1,71 @@
+/****************************************************************************
+ * Timing functions.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "timing.h"
+
+static const unsigned long MAX_TIME_SECONDS = 60;
+
+/****************************************************************************
+ * Get the current time in milliseconds since midnight 1970-01-01 UTC.
+ ****************************************************************************/
+void GetCurrentTime(TimeType *t) {
+	struct timeval val;
+	gettimeofday(&val, NULL);
+	t->seconds = val.tv_sec;
+	t->ms = val.tv_usec / 1000;
+}
+
+/****************************************************************************
+ * Get the absolute difference between two times in milliseconds.
+ * If the difference is larger than a MAX_TIME_SECONDS, then
+ * MAX_TIME_SECONDS will be returned.
+ * Note that the times must be normalized.
+ ****************************************************************************/
+unsigned long GetTimeDifference(const TimeType *t1, const TimeType *t2) {
+	unsigned long deltaSeconds;
+	int deltaMs;
+
+	if(t1->seconds > t2->seconds) {
+		deltaSeconds = t1->seconds - t2->seconds;
+		deltaMs = t1->ms - t2->ms;
+	} else if(t1->seconds < t2->seconds) {
+		deltaSeconds = t2->seconds - t1->seconds;
+		deltaMs = t2->ms - t1->ms;
+	} else if(t1->ms > t2->ms) {
+		deltaSeconds = 0;
+		deltaMs = t1->ms - t2->ms;
+	} else {
+		deltaSeconds = 0;
+		deltaMs = t2->ms - t1->ms;
+	}
+
+	if(deltaSeconds > MAX_TIME_SECONDS) {
+		return MAX_TIME_SECONDS * 1000;
+	} else {
+		return deltaSeconds * 1000 + deltaMs;
+	}
+
+}
+
+/****************************************************************************
+ * Get the current time.
+ * Not reenterent.
+ ****************************************************************************/
+const char *GetTimeString(const char *format) {
+
+	static char str[80];
+	time_t t;
+
+	Assert(format);
+
+	time(&t);
+	strftime(str, sizeof(str), format, localtime(&t));
+
+	return str;
+
+}
+
+
diff --git a/src/timing.h b/src/timing.h
new file mode 100644
index 0000000..25a8fca
--- /dev/null
+++ b/src/timing.h
@@ -0,0 +1,43 @@
+/**
+ * @file timing.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Timing functions.
+ *
+ */
+
+#ifndef TIMING_H
+#define TIMING_H
+
+#define ZERO_TIME { 0, 0 }
+
+typedef struct TimeType {
+
+	unsigned long seconds;
+	int ms;
+
+} TimeType;
+
+/** Get the current time.
+ * @param t The TimeType to fill.
+ */
+void GetCurrentTime(TimeType *t);
+
+/** Get the difference between two times.
+ * Note that the times must be normalized.
+ * @param t1 The first time.
+ * @param t2 The second time.
+ */
+unsigned long GetTimeDifference(const TimeType *t1, const TimeType *t2);
+
+/** Get a time string.
+ * Note that the string returned is a static value and should not be
+ * deleted. Therefore, this function is not thread safe.
+ * @param format The format to use for the string.
+ * @return The time string.
+ */
+const char *GetTimeString(const char *format);
+
+#endif
+
diff --git a/src/tray.c b/src/tray.c
new file mode 100644
index 0000000..d30dd1e
--- /dev/null
+++ b/src/tray.c
@@ -0,0 +1,1104 @@
+/***************************************************************************
+ * Functions to handle the tray.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "tray.h"
+#include "color.h"
+#include "main.h"
+#include "pager.h"
+#include "cursor.h"
+#include "error.h"
+#include "taskbar.h"
+#include "menu.h"
+#include "timing.h"
+
+#define DEFAULT_TRAY_WIDTH 32
+#define DEFAULT_TRAY_HEIGHT 32
+
+static TrayType *trays;
+static Window supportingWindow;
+
+static void HandleTrayExpose(TrayType *tp, const XExposeEvent *event);
+static void HandleTrayEnterNotify(TrayType *tp, const XCrossingEvent *event);
+
+static void HandleTrayButtonPress(TrayType *tp, const XButtonEvent *event);
+static void HandleTrayMotionNotify(TrayType *tp, const XMotionEvent *event);
+
+static void ComputeTraySize(TrayType *tp);
+static int ComputeMaxWidth(TrayType *tp);
+static int ComputeTotalWidth(TrayType *tp);
+static int ComputeMaxHeight(TrayType *tp);
+static int ComputeTotalHeight(TrayType *tp);
+static int CheckHorizontalFill(TrayType *tp);
+static int CheckVerticalFill(TrayType *tp);
+static void LayoutTray(TrayType *tp, int *variableSize,
+	int *variableRemainder);
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeTray() {
+	trays = NULL;
+	supportingWindow = None;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void StartupTray() {
+
+	XSetWindowAttributes attr;
+	unsigned long attrMask;
+	TrayType *tp;
+	TrayComponentType *cp;
+	int variableSize;
+	int variableRemainder;
+	int width, height;
+	int xoffset, yoffset;
+
+	for(tp = trays; tp; tp = tp->next) {
+
+		LayoutTray(tp, &variableSize, &variableRemainder);
+
+		/* Create the tray window. */
+		/* The window is created larger for a border. */
+		attrMask = CWOverrideRedirect;
+		attr.override_redirect = True;
+
+		/* We can't use PointerMotionHintMask since the exact position
+		 * of the mouse on the tray is important for popups. */
+		attrMask |= CWEventMask;
+		attr.event_mask
+			= ButtonPressMask
+			| SubstructureNotifyMask
+			| ExposureMask
+			| KeyPressMask
+			| EnterWindowMask
+			| PointerMotionMask;
+
+		attrMask |= CWBackPixel;
+		attr.background_pixel = colors[COLOR_TRAY_BG];
+
+		tp->window = JXCreateWindow(display, rootWindow,
+			tp->x, tp->y, tp->width, tp->height,
+			0, rootDepth, InputOutput, rootVisual, attrMask, &attr);
+
+		SetDefaultCursor(tp->window);
+
+		/* Create and layout items on the tray. */
+		xoffset = tp->border;
+		yoffset = tp->border;
+		for(cp = tp->components; cp; cp = cp->next) {
+
+			if(cp->Create) {
+				if(tp->layout == LAYOUT_HORIZONTAL) {
+					height = tp->height - 2 * tp->border;
+					width = cp->width;
+					if(width == 0) {
+						width = variableSize;
+						if(variableRemainder) {
+							++width;
+							--variableRemainder;
+						}
+					}
+				} else {
+					width = tp->width - 2 * tp->border;
+					height = cp->height;
+					if(height == 0) {
+						height = variableSize;
+						if(variableRemainder) {
+							++height;
+							--variableRemainder;
+						}
+					}
+				}
+				cp->width = width;
+				cp->height = height;
+				(cp->Create)(cp);
+			}
+
+			cp->x = xoffset;
+			cp->y = yoffset;
+			cp->screenx = tp->x + xoffset;
+			cp->screeny = tp->y + yoffset;
+
+			if(cp->window != None) {
+				JXReparentWindow(display, cp->window, tp->window,
+					xoffset, yoffset);
+			}
+
+			if(tp->layout == LAYOUT_HORIZONTAL) {
+				xoffset += cp->width;
+			} else {
+				yoffset += cp->height;
+			}
+		}
+
+		/* Show the tray. */
+		JXMapWindow(display, tp->window);
+
+	}
+
+	UpdatePager();
+	UpdateTaskBar();
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShutdownTray() {
+
+	TrayType *tp;
+	TrayComponentType *cp;
+
+	for(tp = trays; tp; tp = tp->next) {
+		for(cp = tp->components; cp; cp = cp->next) {
+			if(cp->Destroy) {
+				(cp->Destroy)(cp);
+			}
+		}
+		JXDestroyWindow(display, tp->window);
+	}
+
+	if(supportingWindow != None) {
+		XDestroyWindow(display, supportingWindow);
+		supportingWindow = None;
+	}
+
+}
+
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyTray() {
+
+	TrayType *tp;
+	TrayComponentType *cp;
+
+	while(trays) {
+		tp = trays->next;
+
+		while(trays->components) {
+			cp = trays->components->next;
+			Release(trays->components);
+			trays->components = cp;
+		}
+		Release(trays);
+
+		trays = tp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+TrayType *CreateTray() {
+
+	TrayType *tp;
+
+	tp = Allocate(sizeof(TrayType));
+
+	tp->x = 0;
+	tp->y = -1;
+	tp->requestedWidth = 0;
+	tp->requestedHeight = 0;
+	tp->width = 0;
+	tp->height = 0;
+	tp->border = 1;
+	tp->layer = DEFAULT_TRAY_LAYER;
+	tp->layout = LAYOUT_HORIZONTAL;
+	tp->valign = TALIGN_FIXED;
+	tp->halign = TALIGN_FIXED;
+
+	tp->autoHide = 0;
+	tp->hidden = 0;
+
+	tp->window = None;
+
+	tp->components = NULL;
+	tp->componentsTail = NULL;
+
+	tp->next = trays;
+	trays = tp;
+
+	return tp;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+TrayComponentType *CreateTrayComponent() {
+
+	TrayComponentType *cp;
+
+	cp = Allocate(sizeof(TrayComponentType));
+
+	cp->tray = NULL;
+	cp->object = NULL;
+
+	cp->x = 0;
+	cp->y = 0;
+	cp->requestedWidth = 0;
+	cp->requestedHeight = 0;
+	cp->width = 0;
+	cp->height = 0;
+
+	cp->window = None;
+	cp->pixmap = None;
+
+	cp->Create = NULL;
+	cp->Destroy = NULL;
+
+	cp->SetSize = NULL;
+	cp->Resize = NULL;
+
+	cp->ProcessButtonEvent = NULL;
+	cp->ProcessMotionEvent = NULL;
+
+	cp->next = NULL;
+
+	return cp;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void AddTrayComponent(TrayType *tp, TrayComponentType *cp) {
+
+	Assert(tp);
+	Assert(cp);
+
+	cp->tray = tp;
+
+	if(tp->componentsTail) {
+		tp->componentsTail->next = cp;
+	} else {
+		tp->components = cp;
+	}
+	tp->componentsTail = cp;
+	cp->next = NULL;
+
+}
+
+/***************************************************************************
+ * Compute the max component width.
+ ***************************************************************************/
+int ComputeMaxWidth(TrayType *tp) {
+
+	TrayComponentType *cp;
+	int result;
+	int temp;
+
+	result = 0;
+	for(cp = tp->components; cp; cp = cp->next) {
+		temp = cp->width;
+		if(temp > 0) {
+			temp += 2 * tp->border;
+			if(temp > result) {
+				result = temp;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ComputeTotalWidth(TrayType *tp) {
+
+	TrayComponentType *cp;
+	int result;
+
+	result = 2 * tp->border;
+	for(cp = tp->components; cp; cp = cp->next) {
+		result += cp->width;
+	}
+
+	return result;
+
+}
+
+/***************************************************************************
+ * Compute the max component height.
+ ***************************************************************************/
+int ComputeMaxHeight(TrayType *tp) {
+
+	TrayComponentType *cp;
+	int result;
+	int temp;
+
+	result = 0;
+	for(cp = tp->components; cp; cp = cp->next) {
+		temp = cp->height;
+		if(temp > 0) {
+			temp += 2 * tp->border;
+			if(temp > result) {
+				result = temp;
+			}
+		}
+	}
+
+	return result;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ComputeTotalHeight(TrayType *tp) {
+
+	TrayComponentType *cp;
+	int result;
+
+	result = 2 * tp->border;
+	for(cp = tp->components; cp; cp = cp->next) {
+		result += cp->height;
+	}
+
+	return result;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int CheckHorizontalFill(TrayType *tp) {
+
+	TrayComponentType *cp;
+
+	for(cp = tp->components; cp; cp = cp->next) {
+		if(cp->width == 0) {
+			return 1;
+		}
+	}
+
+	return 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int CheckVerticalFill(TrayType *tp) {
+
+	TrayComponentType *cp;
+
+	for(cp = tp->components; cp; cp = cp->next) {
+		if(cp->height == 0) {
+			return 1;
+		}
+	}
+
+	return 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ComputeTraySize(TrayType *tp) {
+
+	TrayComponentType *cp;
+
+	/* Determine the first dimension. */
+	if(tp->layout == LAYOUT_HORIZONTAL) {
+
+		if(tp->height == 0) {
+			tp->height = ComputeMaxHeight(tp);
+		}
+
+		if(tp->height == 0) {
+			tp->height = DEFAULT_TRAY_HEIGHT;
+		}
+
+	} else {
+
+		if(tp->width == 0) {
+			tp->width = ComputeMaxWidth(tp);
+		}
+
+		if(tp->width == 0) {
+			tp->width = DEFAULT_TRAY_WIDTH;
+		}
+
+	}
+
+	/* Now at least one size is known. Inform the components. */
+	for(cp = tp->components; cp; cp = cp->next) {
+		if(cp->SetSize) {
+			if(tp->layout == LAYOUT_HORIZONTAL) {
+				(cp->SetSize)(cp, 0, tp->height - 2 * tp->border);
+			} else {
+				(cp->SetSize)(cp, tp->width - 2 * tp->border, 0);
+			}
+		}
+	}
+
+	/* Determine the missing dimension. */
+	if(tp->layout == LAYOUT_HORIZONTAL) {
+		if(tp->width == 0) {
+			if(CheckHorizontalFill(tp)) {
+				tp->width = rootWidth;
+			} else {
+				tp->width = ComputeTotalWidth(tp);
+			}
+			if(tp->width == 0) {
+				tp->width = DEFAULT_TRAY_WIDTH;
+			}
+		}
+	} else {
+		if(tp->height == 0) {
+			if(CheckVerticalFill(tp)) {
+				tp->height = rootHeight;
+			} else {
+				tp->height = ComputeTotalHeight(tp);
+			}
+			if(tp->height == 0) {
+				tp->height = DEFAULT_TRAY_HEIGHT;
+			}
+		}
+	}
+
+	/* Compute the tray location. */
+	switch(tp->valign) {
+	case TALIGN_TOP:
+		tp->y = 0;
+		break;
+	case TALIGN_BOTTOM:
+		tp->y = rootHeight - tp->height + 1;
+		break;
+	case TALIGN_CENTER:
+		tp->y = rootHeight / 2 - tp->height / 2;
+		break;
+	default:
+		if(tp->y < 0) {
+			tp->y = rootHeight + tp->y - tp->height + 1;
+		}
+		break;
+	}
+
+	switch(tp->halign) {
+	case TALIGN_LEFT:
+		tp->x = 0;
+		break;
+	case TALIGN_RIGHT:
+		tp->x = rootWidth - tp->width + 1;
+		break;
+	case TALIGN_CENTER:
+		tp->x = rootWidth / 2 - tp->width / 2;
+		break;
+	default:
+		if(tp->x < 0) {
+			tp->x = rootWidth + tp->x - tp->width + 1;
+		}
+		break;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShowTray(TrayType *tp) {
+
+	Window win1, win2;
+	int winx, winy;
+	unsigned int mask;
+	int mousex, mousey;
+
+	if(tp->hidden) {
+
+		tp->hidden = 0;
+		JXMoveWindow(display, tp->window, tp->x, tp->y);
+
+		JXQueryPointer(display, rootWindow, &win1, &win2,
+			&mousex, &mousey, &winx, &winy, &mask);
+		SetMousePosition(mousex, mousey);
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void HideTray(TrayType *tp) {
+
+	int x, y;
+
+	tp->hidden = 1;
+
+	/* Determine where to move the tray. */
+	if(tp->layout == LAYOUT_HORIZONTAL) {
+
+		x = tp->x;
+
+		if(tp->y >= rootHeight / 2) {
+			y = rootHeight - 1;
+		} else {
+			y = 1 - tp->height;
+		}
+
+	} else {
+
+		y = tp->y;
+
+		if(tp->x >= rootWidth / 2) {
+			x = rootWidth - 1;
+		} else {
+			x = 1 - tp->width;
+		}
+
+	}
+
+	/* Move it. */
+	JXMoveWindow(display, tp->window, x, y);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+int ProcessTrayEvent(const XEvent *event) {
+
+	TrayType *tp;
+
+	for(tp = trays; tp; tp = tp->next) {
+		if(event->xany.window == tp->window) {
+			switch(event->type) {
+			case Expose:
+				HandleTrayExpose(tp, &event->xexpose);
+				return 1;
+			case EnterNotify:
+				HandleTrayEnterNotify(tp, &event->xcrossing);
+				return 1;
+			case ButtonPress:
+				HandleTrayButtonPress(tp, &event->xbutton);
+				return 1;
+			case MotionNotify:
+				HandleTrayMotionNotify(tp, &event->xmotion);
+				return 1;
+			default:
+				return 0;
+			}
+		}
+	}
+
+	return 0;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SignalTray(const TimeType *now, int x, int y) {
+
+	TrayType *tp;
+
+	for(tp = trays; tp; tp = tp->next) {
+		if(tp->autoHide && !tp->hidden && !menuShown) {
+			if(x < tp->x || x >= tp->x + tp->width
+				|| y < tp->y || y >= tp->y + tp->height) {
+				HideTray(tp);
+			}
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void HandleTrayExpose(TrayType *tp, const XExposeEvent *event) {
+
+	DrawSpecificTray(tp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void HandleTrayEnterNotify(TrayType *tp, const XCrossingEvent *event) {
+
+	ShowTray(tp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void HandleTrayButtonPress(TrayType *tp, const XButtonEvent *event) {
+
+	TrayComponentType *cp;
+	int xoffset, yoffset;
+	int width, height;
+	int x, y;
+	int mask;
+
+	xoffset = tp->border;
+	yoffset = tp->border;
+	for(cp = tp->components; cp; cp = cp->next) {
+		width = cp->width;
+		height = cp->height;
+		if(event->x >= xoffset && event->x < xoffset + width) {
+			if(event->y >= yoffset && event->y < yoffset + height) {
+				if(cp->ProcessButtonEvent) {
+					x = event->x - xoffset;
+					y = event->y - yoffset;
+					mask = event->button;
+					(cp->ProcessButtonEvent)(cp, x, y, mask);
+				}
+				break;
+			}
+		}
+		if(tp->layout == LAYOUT_HORIZONTAL) {
+			xoffset += width;
+		} else {
+			yoffset += height;
+		}
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void HandleTrayMotionNotify(TrayType *tp, const XMotionEvent *event) {
+
+	TrayComponentType *cp;
+	int xoffset, yoffset;
+	int width, height;
+	int x, y;
+	int mask;
+
+	xoffset = tp->border;
+	yoffset = tp->border;
+	for(cp = tp->components; cp; cp = cp->next) {
+		width = cp->width;
+		height = cp->height;
+		if(event->x >= xoffset && event->x < xoffset + width) {
+			if(event->y >= yoffset && event->y < yoffset + height) {
+				if(cp->ProcessMotionEvent) {
+					x = event->x - xoffset;
+					y = event->y - yoffset;
+					mask = event->state;
+					(cp->ProcessMotionEvent)(cp, x, y, mask);
+				}
+				break;
+			}
+		}
+		if(tp->layout == LAYOUT_HORIZONTAL) {
+			xoffset += width;
+		} else {
+			yoffset += height;
+		}
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DrawTray() {
+
+	TrayType *tp;
+
+	if(shouldExit) {
+		return;
+	}
+
+	for(tp = trays; tp; tp = tp->next) {
+		DrawSpecificTray(tp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DrawSpecificTray(const TrayType *tp) {
+
+	TrayComponentType *cp;
+	int x;
+
+	Assert(tp);
+
+	/* Draw components. */
+	for(cp = tp->components; cp; cp = cp->next) {
+		UpdateSpecificTray(tp, cp);
+	}
+
+	/* Draw the border. */
+	for(x = 0; x < tp->border; x++) {
+
+		/* Top */
+		JXSetForeground(display, rootGC, colors[COLOR_TRAY_UP]);
+		JXDrawLine(display, tp->window, rootGC,
+			0, x,
+			tp->width - x - 1, x);
+
+		/* Bottom */
+		JXSetForeground(display, rootGC, colors[COLOR_TRAY_DOWN]);
+		JXDrawLine(display, tp->window, rootGC,
+			x + 1, tp->height - x - 1,
+			tp->width - x - 2, tp->height - x - 1);
+
+		/* Left */
+		JXSetForeground(display, rootGC, colors[COLOR_TRAY_UP]);
+		JXDrawLine(display, tp->window, rootGC,
+			x, x,
+			x, tp->height - x - 1);
+
+		/* Right */
+		JXSetForeground(display, rootGC, colors[COLOR_TRAY_DOWN]);
+		JXDrawLine(display, tp->window, rootGC, 
+			tp->width - x - 1, x + 1,
+			tp->width - x - 1, tp->height - x - 1);
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void UpdateSpecificTray(const TrayType *tp, const TrayComponentType *cp) {
+
+	if(cp->pixmap != None && !shouldExit) {
+		JXCopyArea(display, cp->pixmap, tp->window, rootGC, 0, 0,
+			cp->width, cp->height, cp->x, cp->y);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void LayoutTray(TrayType *tp, int *variableSize, int *variableRemainder) {
+
+	TrayComponentType *cp;
+	int variableCount;
+	int width, height;
+	int temp;
+
+	tp->width = tp->requestedWidth;
+	tp->height = tp->requestedHeight;
+
+	for(cp = tp->components; cp; cp = cp->next) {
+		cp->width = cp->requestedWidth;
+		cp->height = cp->requestedHeight;
+	}
+
+	ComputeTraySize(tp);
+
+	/* Get the remaining size after setting fixed size components. */
+	/* Also, keep track of the number of variable size components. */
+	width = tp->width - 2 * tp->border;
+	height = tp->height - 2 * tp->border;
+	variableCount = 0;
+	for(cp = tp->components; cp; cp = cp->next) {
+		if(tp->layout == LAYOUT_HORIZONTAL) {
+			temp = cp->width;
+			if(temp > 0) {
+				width -= temp;
+			} else {
+				++variableCount;
+			}
+		} else {
+			temp = cp->height;
+			if(temp > 0) {
+				height -= temp;
+			} else {
+				++variableCount;
+			}
+		}
+	}
+
+	/* Distribute excess size among variable size components.
+	 * If there are no variable size components, shrink the tray.
+	 * If we are out of room, just give them a size of one.
+	 */
+	*variableSize = 1;
+	*variableRemainder = 0;
+	if(tp->layout == LAYOUT_HORIZONTAL) {
+		if(variableCount) {
+			if(width >= variableCount) {
+				*variableSize = width / variableCount;
+				*variableRemainder = width % variableCount;
+			}
+		} else if(width > 0) {
+			tp->width -= width;
+		}
+	} else {
+		if(variableCount) {
+			if(height >= variableCount) {
+				*variableSize = height / variableCount;
+				*variableRemainder = height % variableCount;
+			}
+		} else if(height > 0) {
+			tp->height -= height;
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ResizeTray(TrayType *tp) {
+
+	TrayComponentType *cp;
+	int variableSize;
+	int variableRemainder;
+	int xoffset, yoffset;
+	int width, height;
+
+	Assert(tp);
+
+	LayoutTray(tp, &variableSize, &variableRemainder);
+
+	/* Reposition items on the tray. */
+	xoffset = tp->border;
+	yoffset = tp->border;
+	for(cp = tp->components; cp; cp = cp->next) {
+
+		cp->x = xoffset;
+		cp->y = yoffset;
+		cp->screenx = tp->x + xoffset;
+		cp->screeny = tp->y + yoffset;
+
+		if(cp->Resize) {
+			if(tp->layout == LAYOUT_HORIZONTAL) {
+				height = tp->height - 2 * tp->border;
+				width = cp->width;
+				if(width == 0) {
+					width = variableSize;
+					if(variableRemainder) {
+						++width;
+						--variableRemainder;
+					}
+				}
+			} else {
+				width = tp->width - 2 * tp->border;
+				height = cp->height;
+				if(height == 0) {
+					height = variableSize;
+					if(variableRemainder) {
+						++height;
+						--variableRemainder;
+					}
+				}
+			}
+			cp->width = width;
+			cp->height = height;
+			(cp->Resize)(cp);
+		}
+
+		if(cp->window != None) {
+			JXMoveWindow(display, cp->window, xoffset, yoffset);
+		}
+
+		if(tp->layout == LAYOUT_HORIZONTAL) {
+			xoffset += cp->width;
+		} else {
+			yoffset += cp->height;
+		}
+	}
+
+	JXMoveResizeWindow(display, tp->window, tp->x, tp->y,
+		tp->width, tp->height);
+
+	UpdateTaskBar();
+	DrawSpecificTray(tp);
+
+	if(tp->hidden) {
+		HideTray(tp);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+TrayType *GetTrays() {
+	return trays;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+Window GetSupportingWindow() {
+
+	if(trays) {
+		return trays->window;
+	} else if(supportingWindow != None) {
+		return supportingWindow;
+	} else {
+		supportingWindow = JXCreateSimpleWindow(display, rootWindow,
+			0, 0, 1, 1, 0, 0, 0);
+		return supportingWindow;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetAutoHideTray(TrayType *tp, int v) {
+	Assert(tp);
+	tp->autoHide = v;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayX(TrayType *tp, const char *str) {
+	Assert(tp);
+	Assert(str);
+	tp->x = atoi(str);
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayY(TrayType *tp, const char *str) {
+	Assert(tp);
+	Assert(str);
+	tp->y = atoi(str);
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayWidth(TrayType *tp, const char *str) {
+
+	int width;
+
+	Assert(tp);
+	Assert(str);
+
+	width = atoi(str);
+
+	if(width < 0) {
+		Warning("invalid tray width: %d", width);
+	} else {
+		tp->requestedWidth = width;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayHeight(TrayType *tp, const char *str) {
+
+	int height;
+
+	Assert(tp);
+	Assert(str);
+
+	height = atoi(str);
+
+	if(height < 0) {
+		Warning("invalid tray height: %d", height);
+	} else {
+		tp->requestedHeight = height;
+	}
+
+}
+
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayLayout(TrayType *tp, const char *str) {
+
+	Assert(tp);
+
+	if(!str) {
+
+		/* Compute based on requested size. */
+
+	} else if(!strcmp(str, "horizontal")) {
+
+		tp->layout = LAYOUT_HORIZONTAL;
+		return;
+
+	} else if(!strcmp(str, "vertical")) {
+
+		tp->layout = LAYOUT_VERTICAL;
+		return;
+
+	} else {
+		Warning("invalid tray layout: \"%s\"", str);
+	}
+
+	/* Prefer horizontal layout, but use vertical if
+	 * width is finite and height is larger than width or infinite.
+	 */
+	if(tp->requestedWidth > 0
+		&& (tp->requestedHeight == 0
+		|| tp->requestedHeight > tp->requestedWidth)) {
+		tp->layout = LAYOUT_VERTICAL;
+	} else {
+		tp->layout = LAYOUT_HORIZONTAL;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayLayer(TrayType *tp, const char *str) {
+
+	int temp;
+
+	Assert(tp);
+	Assert(str);
+
+	temp = atoi(str);
+	if(temp < LAYER_BOTTOM || temp > LAYER_TOP) {
+		Warning("invalid tray layer: %d", temp);
+		tp->layer = DEFAULT_TRAY_LAYER;
+	} else {
+		tp->layer = temp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayBorder(TrayType *tp, const char *str) {
+
+	int temp;
+
+	Assert(tp);
+	Assert(str);
+
+	temp = atoi(str);
+	if(temp < MIN_TRAY_BORDER || temp > MAX_TRAY_BORDER) {
+		Warning("invalid tray border: %d", temp);
+		tp->border = DEFAULT_TRAY_BORDER;
+	} else {
+		tp->border = temp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayHorizontalAlignment(TrayType *tp, const char *str) {
+
+	Assert(tp);
+
+	if(!str || !strcmp(str, "fixed")) {
+		tp->halign = TALIGN_FIXED;
+	} else if(!strcmp(str, "left")) {
+		tp->halign = TALIGN_LEFT;
+	} else if(!strcmp(str, "right")) {
+		tp->halign = TALIGN_RIGHT;
+	} else if(!strcmp(str, "center")) {
+		tp->halign = TALIGN_CENTER;
+	} else {
+		Warning("invalid tray horizontal alignment: \"%s\"", str);
+		tp->halign = TALIGN_FIXED;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetTrayVerticalAlignment(TrayType *tp, const char *str) {
+
+	Assert(tp);
+
+	if(!str || !strcmp(str, "fixed")) {
+		tp->valign = TALIGN_FIXED;
+	} else if(!strcmp(str, "top")) {
+		tp->valign = TALIGN_TOP;
+	} else if(!strcmp(str, "bottom")) {
+		tp->valign = TALIGN_BOTTOM;
+	} else if(!strcmp(str, "center")) {
+		tp->valign = TALIGN_CENTER;
+	} else {
+		Warning("invalid tray vertical alignment: \"%s\"", str);
+		tp->valign = TALIGN_FIXED;
+	}
+
+}
+
+
diff --git a/src/tray.h b/src/tray.h
new file mode 100644
index 0000000..bae38c5
--- /dev/null
+++ b/src/tray.h
@@ -0,0 +1,214 @@
+/**
+ * @file tray.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the tray functions.
+ *
+ */
+
+#ifndef TRAY_H
+#define TRAY_H
+
+#include "hint.h"
+
+struct TimeType;
+
+typedef enum {
+	LAYOUT_HORIZONTAL,
+	LAYOUT_VERTICAL
+} LayoutType;
+
+typedef enum {
+	TALIGN_FIXED,
+	TALIGN_LEFT,
+	TALIGN_TOP,
+	TALIGN_CENTER,
+	TALIGN_RIGHT,
+	TALIGN_BOTTOM
+} TrayAlignmentType;
+
+typedef struct TrayComponentType {
+
+	/* The tray containing the component.
+	 * UpdateSpecificTray(TrayType*, TrayComponentType*) should be called
+	 * when content changes.
+	 */
+	struct TrayType *tray;
+
+	/* Additional information needed for the component. */
+	void *object;
+
+	/* Coordinates on the tray (valid only after Create). */
+	int x, y;
+
+	/* Coordinates on the screen (valid only after Create). */
+	int screenx, screeny;
+
+	/* Sizing is handled as follows:
+	 *  - The component is created via a factory method. It sets its
+	 *    requested size (0 for no preference).
+	 *  - The SetSize callback is issued with size constraints
+	 *    (0 for no constraint). The component should update
+	 *    width and height in SetSize.
+	 *  - The Create callback is issued with finalized size information.
+	 * Resizing is handled as follows:
+	 *  - A component determines that it needs to change size. It updates
+	 *    its requested size (0 for no preference).
+	 *  - The component calls ResizeTray.
+	 *  - The SetSize callback is issued with size constraints
+	 *    (0 for no constraint). The component should update
+	 *    width and height in SetSize.
+	 *  - The Resize callback is issued with finalized size information.
+	 */
+
+	/* Requested component size. */
+	int requestedWidth, requestedHeight;
+
+	/* Actual component size. */
+	int width, height;
+
+	/* Content. */
+	Window window;
+	Pixmap pixmap;
+
+	/* Create the component. */
+	void (*Create)(struct TrayComponentType *cp);
+
+	/* Destroy the component. */
+	void (*Destroy)(struct TrayComponentType *cp);
+
+	/* Set the size known so far for items that need width/height ratios.
+	 * Either width or height may be zero.
+	 * This is called before Create.
+	 */
+	void (*SetSize)(struct TrayComponentType *cp, int width, int height);
+
+	/* Resize the component. */
+	void (*Resize)(struct TrayComponentType *cp);
+
+	/* Callback for mouse clicks. */
+	void (*ProcessButtonEvent)(struct TrayComponentType *cp,
+		int x, int y, int mask);
+
+	/* Callback for mouse motion. */
+	void (*ProcessMotionEvent)(struct TrayComponentType *cp,
+		int x, int y, int mask);
+
+	/* The next component in the tray. */
+	struct TrayComponentType *next;
+
+} TrayComponentType;
+
+typedef struct TrayType {
+
+	int x, y;
+	int requestedWidth, requestedHeight;
+	int width, height;
+	int border;
+	WinLayerType layer;
+	LayoutType layout;
+	TrayAlignmentType valign, halign;
+
+	int autoHide;
+	int hidden;
+
+	Window window;
+
+	struct TrayComponentType *components;
+	struct TrayComponentType *componentsTail;
+
+	struct TrayType *next;
+
+} TrayType;
+
+
+void InitializeTray();
+void StartupTray();
+void ShutdownTray();
+void DestroyTray();
+
+/** Create a new tray.
+ * @return A new, empty tray.
+ */
+TrayType *CreateTray();
+
+/** Create a tray component.
+ * @return A new tray component structure.
+ */
+TrayComponentType *CreateTrayComponent();
+
+/** Add a tray component to a tray.
+ * @param tp The tray to update.
+ * @param cp The tray component to add.
+ */
+void AddTrayComponent(TrayType *tp, TrayComponentType *cp);
+
+/** Show a tray.
+ * @param tp The tray to show.
+ */
+void ShowTray(TrayType *tp);
+
+/** Hide a tray.
+ * @param tp The tray to hide.
+ */
+void HideTray(TrayType *tp);
+
+/** Draw all trays. */
+void DrawTray();
+
+/** Draw a specific tray.
+ * @param tp The tray to draw.
+ */
+void DrawSpecificTray(const TrayType *tp);
+
+/** Update a component on a tray.
+ * @param tp The tray containing the component.
+ * @param cp The component that needs updating.
+ */
+void UpdateSpecificTray(const TrayType *tp, const TrayComponentType *cp);
+
+/** Resize a tray.
+ * @param tp The tray to resize containing the new requested size information.
+ */
+void ResizeTray(TrayType *tp);
+
+/** Get a linked list of trays.
+ * @return The trays.
+ */
+TrayType *GetTrays();
+
+/** Get a window to use as the supporting window.
+ * This is used by clients to validate that compliant window manager is
+ * running.
+ * @return The supporting window.
+ */
+Window GetSupportingWindow();
+
+/** Process an event that may be for a tray.
+ * @param event The event to process.
+ * @return 1 if this event was for a tray, 0 otherwise.
+ */
+int ProcessTrayEvent(const XEvent *event);
+
+/** Signal the trays.
+ * This function is called regularly so that autohide, etc. can take place.
+ * @param now The current time.
+ * @param x The mouse x-coordinate (root relative).
+ * @param y The mouse y-coordinate (root relative).
+ */
+void SignalTray(const struct TimeType *now, int x, int y);
+
+void SetAutoHideTray(TrayType *tp, int v);
+void SetTrayX(TrayType *tp, const char *str);
+void SetTrayY(TrayType *tp, const char *str);
+void SetTrayWidth(TrayType *tp, const char *str);
+void SetTrayHeight(TrayType *tp, const char *str);
+void SetTrayLayout(TrayType *tp, const char *str);
+void SetTrayLayer(TrayType *tp, const char *str);
+void SetTrayBorder(TrayType *tp, const char *str);
+void SetTrayHorizontalAlignment(TrayType *tp, const char *str);
+void SetTrayVerticalAlignment(TrayType *tp, const char *str);
+
+#endif
+
diff --git a/src/traybutton.c b/src/traybutton.c
new file mode 100644
index 0000000..b596ba0
--- /dev/null
+++ b/src/traybutton.c
@@ -0,0 +1,454 @@
+/***************************************************************************
+ ***************************************************************************/
+
+#include "jwm.h"
+#include "traybutton.h"
+#include "tray.h"
+#include "icon.h"
+#include "image.h"
+#include "error.h"
+#include "root.h"
+#include "main.h"
+#include "color.h"
+#include "font.h"
+#include "button.h"
+#include "misc.h"
+#include "screen.h"
+#include "desktop.h"
+#include "popup.h"
+#include "timing.h"
+
+#define BUTTON_SIZE 4
+
+typedef struct TrayButtonType {
+
+	TrayComponentType *cp;
+
+	char *label;
+	char *popup;
+	char *iconName;
+	IconNode *icon;
+
+	char *action;
+
+	int mousex;
+	int mousey;
+	TimeType mouseTime;
+
+	struct TrayButtonType *next;
+
+} TrayButtonType;
+
+static TrayButtonType *buttons;
+
+static void CheckedCreate(TrayComponentType *cp);
+static void Create(TrayComponentType *cp);
+static void Destroy(TrayComponentType *cp);
+static void SetSize(TrayComponentType *cp, int width, int height);
+static void Resize(TrayComponentType *cp);
+
+static void ProcessButtonEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+static void ProcessMotionEvent(TrayComponentType *cp,
+	int x, int y, int mask);
+
+/***************************************************************************
+ ***************************************************************************/
+void InitializeTrayButtons() {
+	buttons = NULL;
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void StartupTrayButtons() {
+
+	TrayButtonType *bp;
+
+	for(bp = buttons; bp; bp = bp->next) {
+		if(bp->label) {
+			bp->cp->requestedWidth
+				= GetStringWidth(FONT_TRAYBUTTON, bp->label) + 4;
+			bp->cp->requestedHeight
+				= GetStringHeight(FONT_TRAYBUTTON);
+		} else {
+			bp->cp->requestedWidth = 0;
+			bp->cp->requestedHeight = 0;
+		}
+		if(bp->iconName) {
+			bp->icon = LoadNamedIcon(bp->iconName);
+			if(bp->icon) {
+				bp->cp->requestedWidth += bp->icon->image->width;
+				bp->cp->requestedHeight += bp->icon->image->height;
+			} else {
+				Warning("could not load tray icon: \"%s\"", bp->iconName);
+			}
+		}
+		bp->cp->requestedWidth += 2 * BUTTON_SIZE;
+		bp->cp->requestedHeight += 2 * BUTTON_SIZE;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ShutdownTrayButtons() {
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void DestroyTrayButtons() {
+
+	TrayButtonType *bp;
+
+	while(buttons) {
+		bp = buttons->next;
+		if(buttons->label) {
+			Release(buttons->label);
+		}
+		if(buttons->iconName) {
+			Release(buttons->iconName);
+		}
+		if(buttons->action) {
+			Release(buttons->action);
+		}
+		if(buttons->popup) {
+			Release(buttons->popup);
+		}
+		Release(buttons);
+		buttons = bp;
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+TrayComponentType *CreateTrayButton(const char *iconName,
+	const char *label, const char *action,
+	const char *popup, int width, int height) {
+
+	TrayButtonType *bp;
+	TrayComponentType *cp;
+
+	if((label == NULL || strlen(label) == 0)
+		&& (iconName == NULL || strlen(iconName) == 0)) {
+		Warning("no icon or label for TrayButton");
+		return NULL;
+	}
+
+	if(width < 0) {
+		Warning("invalid TrayButton width: %d", width);
+		width = 0;
+	}
+	if(height < 0) {
+		Warning("invalid TrayButton height: %d", height);
+		height = 0;
+	}
+
+	bp = Allocate(sizeof(TrayButtonType));
+	bp->next = buttons;
+	buttons = bp;
+
+	bp->icon = NULL;
+	if(iconName) {
+		bp->iconName = Allocate(strlen(iconName) + 1);
+		strcpy(bp->iconName, iconName);
+	} else {
+		bp->iconName = NULL;
+	}
+
+	if(label) {
+		bp->label = Allocate(strlen(label) + 1);
+		strcpy(bp->label, label);
+	} else {
+		bp->label = NULL;
+	}
+
+	if(action) {
+		bp->action = Allocate(strlen(action) + 1);
+		strcpy(bp->action, action);
+	} else {
+		bp->action = NULL;
+	}
+
+	if(popup) {
+		bp->popup = Allocate(strlen(popup) + 1);
+		strcpy(bp->popup, popup);
+	} else {
+		bp->popup = NULL;
+	}
+
+	cp = CreateTrayComponent();
+	cp->object = bp;
+	bp->cp = cp;
+	cp->requestedWidth = width;
+	cp->requestedHeight = height;
+
+	cp->Create = CheckedCreate;
+	cp->Destroy = Destroy;
+	cp->SetSize = SetSize;
+	cp->Resize = Resize;
+
+	cp->ProcessButtonEvent = ProcessButtonEvent;
+	if(popup || label) {
+		cp->ProcessMotionEvent = ProcessMotionEvent;
+	}
+
+	return cp;
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SetSize(TrayComponentType *cp, int width, int height) {
+
+	TrayButtonType *bp;
+	int labelWidth, labelHeight;
+	int iconWidth, iconHeight;
+	double ratio;
+
+	bp = (TrayButtonType*)cp->object;
+
+	if(bp->icon) {
+
+		if(bp->label) {
+			labelWidth = GetStringWidth(FONT_TRAYBUTTON, bp->label) + 4;
+			labelHeight = GetStringHeight(FONT_TRAYBUTTON);
+		} else {
+			labelWidth = 0;
+			labelHeight = 0;
+		}
+
+		iconWidth = bp->icon->image->width;
+		iconHeight = bp->icon->image->height;
+		ratio = (double)iconWidth / iconHeight;
+
+		if(width > 0) {
+
+			/* Compute height from width. */
+			iconWidth = width - labelWidth - 2 * BUTTON_SIZE;
+			iconHeight = iconWidth / ratio;
+			height = Max(iconHeight, labelHeight) + 2 * BUTTON_SIZE;
+
+		} else if(height > 0) {
+
+			/* Compute width from height. */
+			iconHeight = height - 2 * BUTTON_SIZE;
+			iconWidth = iconHeight * ratio;
+			width = iconWidth + labelWidth + 2 * BUTTON_SIZE;
+
+		}
+
+		cp->width = width;
+		cp->height = height;
+
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void CheckedCreate(TrayComponentType *cp) {
+
+	TrayButtonType *bp;
+
+	bp = (TrayButtonType*)cp->object;
+
+	/* Validate the action for this tray button. */
+	if(bp->action && strlen(bp->action) > 0) {
+		if(!strncmp(bp->action, "exec:", 5)) {
+			/* Valid. */
+		} else if(!strncmp(bp->action, "root:", 5)) {
+			/* Valid. However, the specified root menu may not exist.
+			 * This case is handled in ValidateTrayButtons.
+			 */
+		} else if(!strcmp(bp->action, "showdesktop")) {
+			/* Valid. */
+		} else {
+			Warning("invalid TrayButton action: \"%s\"", bp->action);
+		}
+	} else {
+		/* Valid. However, root menu 1 may not exist.
+		 * This case is handled in ValidateTrayButtons.
+		 */
+	}
+
+	Create(cp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Create(TrayComponentType *cp) {
+
+	ButtonNode button;
+	TrayButtonType *bp;
+	int labelx;
+
+	bp = (TrayButtonType*)cp->object;
+
+	cp->pixmap = JXCreatePixmap(display, rootWindow,
+		cp->width, cp->height, rootDepth);
+
+	JXSetForeground(display, rootGC, colors[COLOR_TRAYBUTTON_BG]);
+	JXFillRectangle(display, cp->pixmap, rootGC, 0, 0, cp->width, cp->height);
+
+	ResetButton(&button, cp->pixmap, rootGC);
+	button.type = BUTTON_TASK;
+	button.width = cp->width - 3;
+	button.height = cp->height - 3;
+	button.x = 1;
+	button.y = 1;
+	DrawButton(&button);
+
+	/* Compute the offset of the text. */
+	if(bp->label) {
+		if(!bp->icon) {
+			labelx = 2 + cp->width / 2;
+			labelx -= GetStringWidth(FONT_TRAYBUTTON, bp->label) / 2;
+		} else {
+			labelx = cp->width;
+			labelx -= GetStringWidth(FONT_TRAYBUTTON, bp->label) + 4;
+		}
+	} else {
+		labelx = cp->width;
+	}
+	labelx -= BUTTON_SIZE;
+
+	if(bp->icon) {
+		PutIcon(bp->icon, cp->pixmap, BUTTON_SIZE, BUTTON_SIZE,
+			labelx - BUTTON_SIZE, cp->height - BUTTON_SIZE * 2);
+	}
+
+	if(bp->label) {
+		RenderString(cp->pixmap, FONT_TRAYBUTTON, COLOR_TRAYBUTTON_FG,
+			labelx + 2, cp->height / 2 - GetStringHeight(FONT_TRAYBUTTON) / 2,
+			cp->width - labelx, NULL, bp->label);
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Resize(TrayComponentType *cp) {
+
+	Destroy(cp);
+	Create(cp);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void Destroy(TrayComponentType *cp) {
+	if(cp->pixmap != None) {
+		JXFreePixmap(display, cp->pixmap);
+	}
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ProcessButtonEvent(TrayComponentType *cp, int x, int y, int mask) {
+
+	const ScreenType *sp;
+	int mwidth, mheight;
+	int button;
+
+	TrayButtonType *bp = (TrayButtonType*)cp->object;
+
+	Assert(bp);
+
+	if(bp->action && strlen(bp->action) > 0) {
+		if(!strncmp(bp->action, "exec:", 5)) {
+			RunCommand(bp->action + 5);
+			return;
+		} else if(!strncmp(bp->action, "root:", 5)) {
+			button = atoi(bp->action + 5);
+		} else if(!strcmp(bp->action, "showdesktop")) {
+			ShowDesktop();
+			return;
+		} else {
+			return;
+		}
+	} else {
+		button = 1;
+	}
+
+	GetRootMenuSize(button, &mwidth, &mheight);
+
+	sp = GetCurrentScreen(cp->screenx, cp->screeny);
+
+	if(cp->tray->layout == LAYOUT_HORIZONTAL) {
+		x = cp->screenx;
+		if(cp->screeny + cp->height / 2 < sp->y + sp->height / 2) {
+			y = cp->screeny + cp->height;
+		} else {
+			y = cp->screeny - mheight;
+		}
+	} else {
+		y = cp->screeny;
+		if(cp->screenx + cp->width / 2 < sp->x + sp->width / 2) {
+			x = cp->screenx + cp->width;
+		} else {
+			x = cp->screenx - mwidth;
+		}
+	}
+
+	ShowRootMenu(button, x, y);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ProcessMotionEvent(TrayComponentType *cp, int x, int y, int mask) {
+
+	TrayButtonType *bp = (TrayButtonType*)cp->object;
+
+	bp->mousex = cp->screenx + x;
+	bp->mousey = cp->screeny + y;
+	GetCurrentTime(&bp->mouseTime);
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void SignalTrayButton(const TimeType *now, int x, int y) {
+
+	TrayButtonType *bp;
+	const char *popup;
+
+	for(bp = buttons; bp; bp = bp->next) {
+		if(bp->popup) {
+			popup = bp->popup;
+		} else if(bp->label) {
+			popup = bp->label;
+		} else {
+			continue;
+		}
+		if(abs(bp->mousex - x) < POPUP_DELTA
+			&& abs(bp->mousey - y) < POPUP_DELTA) {
+			if(GetTimeDifference(now, &bp->mouseTime) >= popupDelay) {
+				ShowPopup(x, y, popup);
+			}
+		}
+	}
+
+}
+
+/***************************************************************************
+ ***************************************************************************/
+void ValidateTrayButtons() {
+
+	TrayButtonType *bp;
+	int bindex;
+
+	for(bp = buttons; bp; bp = bp->next) {
+		if(bp->action && !strncmp(bp->action, "root:", 5)) {
+			bindex = atoi(bp->action + 5);
+			if(!IsRootMenuDefined(bindex)) {
+				Warning("tray button: root menu %d not defined", bindex);
+			}
+		}
+	}
+
+}
+
diff --git a/src/traybutton.h b/src/traybutton.h
new file mode 100644
index 0000000..bd22494
--- /dev/null
+++ b/src/traybutton.h
@@ -0,0 +1,51 @@
+/**
+ * @file traybutton.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Tray button tray component.
+ *
+ */
+
+#ifndef TRAY_BUTTON_H
+#define TRAY_BUTTON_H
+
+struct TrayComponentType;
+struct TimeType;
+
+/*@{*/
+void InitializeTrayButtons();
+void StartupTrayButtons();
+void ShutdownTrayButtons();
+void DestroyTrayButtons();
+/*@}*/
+
+/** Create a tray button component.
+ * @param iconName The name of the icon to use for the button.
+ * @param label The label to use for the button.
+ * @param action The action to take when the button is clicked.
+ * @param popup Text to display in a popup window.
+ * @param width The width to use for the button (0 for default).
+ * @param height The height to use for the button (0 for default).
+ * @return A new tray button component.
+ */
+struct TrayComponentType *CreateTrayButton(
+	const char *iconName, const char *label, const char *action,
+	const char *popup, int width, int height);
+
+/** Signal a tray button.
+ * @param now The current time.
+ * @param x The x-coordinate of the mouse (root relative).
+ * @param y The y-coordinate of the mouse (root relative).
+ */
+void SignalTrayButton(const struct TimeType *now, int x, int y);
+
+/** Validate the tray buttons and print a warning if something is wrong.
+ * This is called after parsing the configuration file(s) to determine
+ * if a root menu is defined for each each tray button that specifies
+ * a root menu.
+ */
+void ValidateTrayButtons();
+
+#endif
+
diff --git a/src/winmenu.c b/src/winmenu.c
new file mode 100644
index 0000000..7b537cc
--- /dev/null
+++ b/src/winmenu.c
@@ -0,0 +1,327 @@
+/****************************************************************************
+ * Functions for handling window menus.
+ * Copyright (C) 2004 Joe Wingbermuehle
+ ****************************************************************************/
+
+#include "jwm.h"
+#include "winmenu.h"
+#include "client.h"
+#include "menu.h"
+#include "main.h"
+#include "desktop.h"
+#include "move.h"
+#include "resize.h"
+#include "event.h"
+#include "cursor.h"
+#include "misc.h"
+
+static const char *SENDTO_TEXT = "Send To";
+static const char *LAYER_TEXT = "Layer";
+
+static Menu *CreateWindowMenu();
+static void RunWindowCommand(const MenuAction *action);
+
+static void CreateWindowLayerMenu(Menu *menu);
+static void CreateWindowSendToMenu(Menu *menu);
+static void AddWindowMenuItem(Menu *menu, const char *name,
+	MenuActionType type, int value);
+
+static ClientNode *client = NULL;
+
+/****************************************************************************
+ ****************************************************************************/
+void GetWindowMenuSize(ClientNode *np, int *width, int *height) {
+
+	Menu *menu;
+
+	client = np;
+	menu = CreateWindowMenu();
+	InitializeMenu(menu);
+	*width = menu->width;
+	*height = menu->height;
+	DestroyMenu(menu);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ShowWindowMenu(ClientNode *np, int x, int y) {
+
+	Menu *menu;
+
+	client = np;
+	menu = CreateWindowMenu();
+
+	InitializeMenu(menu);
+
+	ShowMenu(menu, RunWindowCommand, x, y);
+
+	DestroyMenu(menu);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+Menu *CreateWindowMenu() {
+
+	Menu *menu;
+
+	menu = Allocate(sizeof(Menu));
+	menu->itemHeight = 0;
+	menu->items = NULL;
+	menu->label = NULL;
+
+	/* Note that items are added in reverse order of display. */
+
+	if(!(client->state.status & STAT_WMDIALOG)) {
+		AddWindowMenuItem(menu, "Close", MA_CLOSE, 0);
+		AddWindowMenuItem(menu, "Kill", MA_KILL, 0);
+		AddWindowMenuItem(menu, NULL, MA_NONE, 0);
+	}
+
+	if(client->state.status & (STAT_MAPPED | STAT_SHADED)) {
+		if(client->state.border & BORDER_RESIZE) {
+			AddWindowMenuItem(menu, "Resize", MA_RESIZE, 0);
+		}
+		if(client->state.border & BORDER_MOVE) {
+			AddWindowMenuItem(menu, "Move", MA_MOVE, 0);
+		}
+	}
+
+	if(client->state.border & BORDER_MIN) {
+
+		if(client->state.status & STAT_MINIMIZED) {
+			AddWindowMenuItem(menu, "Restore", MA_RESTORE, 0);
+		} else {
+			if(client->state.status & STAT_SHADED) {
+				AddWindowMenuItem(menu, "Unshade", MA_SHADE, 0);
+			} else {
+				AddWindowMenuItem(menu, "Shade", MA_SHADE, 0);
+			}
+			AddWindowMenuItem(menu, "Minimize", MA_MINIMIZE, 0);
+		}
+
+	}
+
+	if((client->state.border & BORDER_MAX)
+		&& (client->state.status & STAT_MAPPED)) {
+
+		AddWindowMenuItem(menu, "Maximize", MA_MAXIMIZE, 0);
+	}
+
+	if(!(client->state.status & STAT_WMDIALOG)) {
+
+		if(client->state.status & STAT_STICKY) {
+			AddWindowMenuItem(menu, "Unstick", MA_STICK, 0);
+		} else {
+			AddWindowMenuItem(menu, "Stick", MA_STICK, 0);
+		}
+
+		CreateWindowLayerMenu(menu);
+
+		if(!(client->state.status & STAT_STICKY)) {
+			CreateWindowSendToMenu(menu);
+		}
+
+	}
+
+	return menu;
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void CreateWindowLayerMenu(Menu *menu) {
+
+	Menu *submenu;
+	MenuItem *item;
+	char str[10];
+	unsigned int x;
+
+	item = Allocate(sizeof(MenuItem));
+	item->type = MENU_ITEM_SUBMENU;
+	item->name = CopyString(LAYER_TEXT);
+	item->action.type = MA_NONE;
+	item->action.data.str = NULL;
+	item->iconName = NULL;
+
+	item->next = menu->items;
+	menu->items = item;
+
+	submenu = Allocate(sizeof(Menu));
+	item->submenu = submenu;
+	submenu->itemHeight = 0;
+	submenu->items = NULL;
+	submenu->label = NULL;
+
+	if(client->state.layer == LAYER_TOP) {
+		AddWindowMenuItem(submenu, "[Top]", MA_LAYER, LAYER_TOP);
+	} else {
+		AddWindowMenuItem(submenu, "Top", MA_LAYER, LAYER_TOP);
+	}
+
+	str[4] = 0;
+	for(x = LAYER_TOP - 1; x > LAYER_BOTTOM; x--) {
+		if(x == LAYER_NORMAL) {
+			if(client->state.layer == x) {
+				AddWindowMenuItem(submenu, "[Normal]", MA_LAYER, x);
+			} else {
+				AddWindowMenuItem(submenu, "Normal", MA_LAYER, x);
+			}
+		} else {
+			if(client->state.layer == x) {
+				str[0] = '[';
+				str[3] = ']';
+			} else {
+				str[0] = ' ';
+				str[3] = ' ';
+			}
+			if(x < 10) {
+				str[1] = ' ';
+			} else {
+				str[1] = (x / 10) + '0';
+			}
+			str[2] = (x % 10) + '0';
+			AddWindowMenuItem(submenu, str, MA_LAYER, x);
+		}
+	}
+
+	if(client->state.layer == LAYER_BOTTOM) {
+		AddWindowMenuItem(submenu, "[Bottom]", MA_LAYER, LAYER_BOTTOM);
+	} else {
+		AddWindowMenuItem(submenu, "Bottom", MA_LAYER, LAYER_BOTTOM);
+	}
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void CreateWindowSendToMenu(Menu *menu) {
+
+	unsigned int mask;
+	unsigned int x;
+
+	mask = 0;
+	for(x = 0; x < desktopCount; x++) {
+		if(client->state.desktop == x
+			|| (client->state.status & STAT_STICKY)) {
+			mask |= 1 << x;
+		}
+	}
+
+	AddWindowMenuItem(menu, SENDTO_TEXT, MA_NONE, 0);
+
+	/* Now the first item in the menu is for the desktop list. */
+	menu->items->submenu = CreateDesktopMenu(mask);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void AddWindowMenuItem(Menu *menu, const char *name,
+	MenuActionType type, int value) {
+
+	MenuItem *item;
+
+	item = Allocate(sizeof(MenuItem));
+	if(name) {
+		item->type = MENU_ITEM_NORMAL;
+	} else {
+		item->type = MENU_ITEM_SEPARATOR;
+	}
+	item->name = CopyString(name);
+	item->action.type = type;
+	item->action.data.i = value;
+	item->iconName = NULL;
+	item->submenu = NULL;
+
+	item->next = menu->items;
+	menu->items = item;
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void ChooseWindow(const MenuAction *action) {
+
+	XEvent event;
+	ClientNode *np;
+
+	GrabMouseForChoose();
+
+	for(;;) {
+
+		WaitForEvent(&event);
+
+		if(event.type == ButtonPress) {
+			if(event.xbutton.button == Button1) {
+				np = FindClientByWindow(event.xbutton.subwindow);
+				if(np) {
+					client = np;
+					RunWindowCommand(action);
+				}
+			}
+			break;
+		} else if(event.type == KeyPress) {
+			break;
+		}
+
+	}
+
+	JXUngrabPointer(display, CurrentTime);
+
+}
+
+/****************************************************************************
+ ****************************************************************************/
+void RunWindowCommand(const MenuAction *action) {
+
+	switch(action->type) {
+	case MA_STICK:
+		if(client->state.status & STAT_STICKY) {
+			SetClientSticky(client, 0);
+		} else {
+			SetClientSticky(client, 1);
+		}
+		break;
+	case MA_MAXIMIZE:
+		MaximizeClient(client);
+		break;
+	case MA_MINIMIZE:
+		MinimizeClient(client);
+		break;
+	case MA_RESTORE:
+		RestoreClient(client, 1);
+		break;
+	case MA_CLOSE:
+		DeleteClient(client);
+		break;
+	case MA_SENDTO:
+	case MA_DESKTOP:
+		SetClientDesktop(client, action->data.i);
+		break;
+	case MA_SHADE:
+		if(client->state.status & STAT_SHADED) {
+			UnshadeClient(client);
+		} else {
+			ShadeClient(client);
+		}
+		break;
+	case MA_MOVE:
+		MoveClientKeyboard(client);
+		break;
+	case MA_RESIZE:
+		ResizeClientKeyboard(client);
+		break;
+	case MA_KILL:
+		KillClient(client);
+		break;
+	case MA_LAYER:
+		SetClientLayer(client, action->data.i);
+		break;
+	default:
+		Debug("unknown window command: %d", action->type);
+		break;
+	}
+
+}
+
diff --git a/src/winmenu.h b/src/winmenu.h
new file mode 100644
index 0000000..a7b1f6e
--- /dev/null
+++ b/src/winmenu.h
@@ -0,0 +1,37 @@
+/**
+ * @file tray.h
+ * @author Joe Wingbermuehle
+ * @date 2004-2006
+ *
+ * @brief Header for the window menu functions.
+ *
+ */
+
+#ifndef WINMENU_H
+#define WINMENU_H
+
+#include "menu.h"
+
+struct ClientNode;
+
+/** Get the size of a window menu.
+ * @param np The client for the window menu.
+ * @param width The width return.
+ * @param heigth The height return.
+ */
+void GetWindowMenuSize(struct ClientNode *np, int *width, int *height);
+
+/** Show a window menu.
+ * @param np The client for the window menu.
+ * @param x The x-coordinate of the menu (root relative).
+ * @param y The y-coordinate of the menu (root relative).
+ */
+void ShowWindowMenu(struct ClientNode *np, int x, int y);
+
+/** Grab the mouse to select a window.
+ * @param action The action to perform when a window is selected.
+ */
+void ChooseWindow(const MenuAction *action); 
+
+#endif
+
diff --git a/src/x.xpm b/src/x.xpm
new file mode 100644
index 0000000..1e9376c
--- /dev/null
+++ b/src/x.xpm
@@ -0,0 +1,32 @@
+static char *x_xpm[]={
+"28 28 2 1",
+". c None",
+"# c #ff0000",
+"............................",
+"............................",
+"............................",
+"............................",
+".########..............##...",
+"..########............##....",
+"...########..........##.....",
+"....########........##......",
+".....########......##.......",
+"......########....##........",
+".......########..##.........",
+"........######..##..........",
+".........####..##...........",
+"..........##..####..........",
+".........##..######.........",
+"........##..########........",
+".......##....########.......",
+"......##......########......",
+".....##........########.....",
+"....##..........########....",
+"...##............########...",
+"..##..............########..",
+".##................########.",
+"............................",
+"............................",
+"............................",
+"............................",
+"............................"};