Commit: 2d04c16ab155d09e5f2508fe76394bcc751b13fc - trjp_sawfish (git)

Japanese translation of message catalog for Sawfish Window-Manager

Commit MetaInfo

• Révision: 2d04c16ab155d09e5f2508fe76394bcc751b13fc (tree)
• l'heure: 2002-03-21 16:50:37
• Auteur: John Harper <jsh@src....>
• Commiter: John Harper

Message de Log

Merged changes from HEAD (up to current location of gnome-2-merged-HEAD tag)

Change Summary

• modified: ChangeLog
• modified: configure.in
• modified: src/ChangeLog
• add: src/frames.c
• add: src/functions.c
• add: src/windows.c

Modification

--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,45 @@
[phone]  John Harper  <[e-mail]>
+
+	* Merged changes from HEAD:
+
+	2002-03-17  T?vo Leedj?v  <[e-mail]>
+
+	* po/et.po: Updated Estonian translation.
+
+	2002-03-17  T?vo Leedj?v  <[e-mail]>
+
+	* po/et.po: Added Estonian translation from gnome-2 branch.
+
+	2002-03-15  Valek Filippov  <[e-mail]>
+
+	* ru.po: updated russian translation.
+
+	2002-02-28  Hasbullah Bin Pit <[e-mail]>
+
+	* po/ms.po: Added Malay Translation from gnome-2 branch
+
+	2002-02-20  John Harper  <[e-mail]>
+
+	* configure.in: don't ever compile our own dlmalloc, it breaks
+	on too many platforms
+
+	2002-02-01  Kjartan Maraas  <[e-mail]>
+
+	* po/no.po: Updated Norwegian (bokm?) translation.
+	
+	2002-01-31  Simos Xenitellis  <[e-mail]>
+
+	* po/el.po: Updated Greek translation.
+
+	2002-01-23  Peteris Krisjanis <[e-mail]>
+
+	* po/lv.po: Updated Latvian translation.
+
+	2002-01-15  Wang Jian  <[e-mail]>
+
+	* po/zh_CN.po: Updated Simplified Chinese translation by
+	Wang Li <[e-mail]>.
+	
 2002-03-17  T?vo Leedj?v  <[e-mail]>
 
 	* po/et.po: Updated Estonian translation.
@@ -66,7 +108,7 @@
 
 2002-01-04  Pablo Saratxaga  <[e-mail]>
 
-        * configure.in: Added "eu" to ALL_LINGUAS
+	* configure.in: Added "eu" to ALL_LINGUAS
 
 2001-12-17  Germ? Poo-Caama?  <[e-mail]>
 

--- a/configure.in
+++ b/configure.in
@@ -249,25 +249,15 @@ else
 fi
 AC_SUBST(REP_GTK_GNOME)
 
-dnl Check for Doug Lea's malloc in libc, otherwise compile dlmalloc.c
+dnl Check for Doug Lea's malloc in libc
 doug_lea_malloc=yes
 AC_CHECK_FUNC(malloc_get_state, , doug_lea_malloc=no)
 AC_CHECK_FUNC(malloc_set_state, , doug_lea_malloc=no)
 if test "$doug_lea_malloc" = "no"; then
-  dnl dlmalloc is broken on Tru64, and may be broken on some
-  dnl solaris platforms
-  case ${host} in
-    *-dec-osf*)
-      AC_DEFINE(LIBC_MALLOC)
-      ;;
-    *-sparc-sun*)
-      AC_DEFINE(LIBC_MALLOC)
-      ;;
-    *)
-      LIBOBJS="${LIBOBJS} dlmalloc.o"
-      AC_DEFINE(DOUG_LEA_MALLOC)
-      ;;
-  esac
+  dnl We used to compile our own version of dlmalloc on most
+  dnl platforms that didn't have it in their libc. But the list
+  dnl of exceptions was growing too long..
+  AC_DEFINE(LIBC_MALLOC)
 else
   AC_DEFINE(DOUG_LEA_MALLOC)
   AC_DEFINE(LIBC_MALLOC)

--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,25 @@
[phone]  John Harper  <[e-mail]>
+
+	* Merged changes from HEAD:
+
+	2002-03-01  John Harper  <[e-mail]>
+
+	* windows.c (manage_windows): unmap the window before faking
+	the call to the map-request event handler. Fixes #67601 (causes
+	the expected map-notify event to be sent when we later map it)
+
+	2002-02-17  John Harper  <[e-mail]>
+
+	* windows.c (remove_window): check for w->id == 0 immediately
+	before calling remove_from_stacking_list (). Avoids triggering
+	an assertion on logout (since remove_window () may be called
+	recursively from the error handler!)
+
+	2002-01-24  John Harper  <[e-mail]>
+
+	* frames.c: fixed definitions of Qtop and Qbottom. This bug
+	must have existed forever!
+
 2002-01-10  Sander Vesik <[e-mail]>
 
 	* image.c: gdk_pixbuf_new_from_file now takes two parameters

--- /dev/null
+++ b/src/frames.c
@@ -0,0 +1,1950 @@
+/* frames.c -- window frame manipulation
+   $Id$
+
+   Copyright (C) 1999, 2000 John Harper <[e-mail]>
+
+   This file is part of sawmill.
+
+   sawmill 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, or (at your option)
+   any later version.
+
+   sawmill 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 sawmill; see the file COPYING.   If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* AIX requires this to be the first thing in the file.  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+ #pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+   char *alloca ();
+#   endif
+#  endif
+# endif
+#endif
+   
+#include "sawmill.h"
+#include <X11/Xutil.h>
+#include <X11/Xresource.h>
+#include <X11/extensions/shape.h>
+#include <assert.h>
+
+static XID window_fp_context;
+
+int frame_part_type;
+static struct frame_part *allocated_parts;
+
+DEFSYM(internal, "internal");
+DEFSYM(tiled, "tiled");
+DEFSYM(center, "center");
+DEFSYM(right, "right");
+DEFSYM(left, "left");
+DEFSYM(top, "top");
+DEFSYM(bottom, "bottom");
+DEFSYM(text, "text");
+DEFSYM(x_justify, "x-justify");
+DEFSYM(y_justify, "y-justify");
+DEFSYM(background, "background");
+DEFSYM(foreground, "foreground");
+DEFSYM(renderer, "renderer");
+DEFSYM(render_scale, "render-scale");
+DEFSYM(font, "font");
+DEFSYM(width, "width");
+DEFSYM(height, "height");
+DEFSYM(left_edge, "left-edge");
+DEFSYM(top_edge, "top-edge");
+DEFSYM(right_edge, "right-edge");
+DEFSYM(bottom_edge, "bottom-edge");
+DEFSYM(cursor, "cursor");
+DEFSYM(focused, "focused");
+DEFSYM(highlighted, "highlighted");
+DEFSYM(clicked, "clicked");
+DEFSYM(inactive, "inactive");
+DEFSYM(inactive_highlighted, "inactive-highlighted");
+DEFSYM(inactive_clicked, "inactive-clicked");
+DEFSYM(hide_client, "hide-client");
+DEFSYM(class, "class");
+DEFSYM(removable, "removable");
+DEFSYM(removed_classes, "removed-classes");
+DEFSYM(frame_part_classes, "frame-part-classes");
+DEFSYM(override_frame_part_classes, "override-frame-part-classes");
+DEFSYM(below_client, "below-client");
+DEFSYM(scale_foreground, "scale-foreground");
+DEFSYM(hidden, "hidden");
+
+static repv state_syms[fps_MAX];
+
+static bool frame_draw_mutex;
+bool frame_state_mutex;
+
+
+/* type hooks */
+
+static struct frame_part *
+fp_new (Lisp_Window *win, repv alist)
+{
+    struct frame_part *fp = rep_ALLOC_CELL (sizeof (struct frame_part));
+    rep_data_after_gc += sizeof (struct frame_part);
+    memset (fp, 0, sizeof (struct frame_part));
+    fp->car = frame_part_type;
+    fp->win = win;
+    fp->alist = alist;
+    fp->local_alist = Qnil;
+    fp->next_alloc = allocated_parts;
+    allocated_parts = fp;
+    return fp;
+}
+
+static int
+fp_cmp (repv w1, repv w2)
+{
+    return w1 != w2;
+}
+
+static void
+fp_prin (repv stream, repv win)
+{
+    char buf[128];
+    sprintf (buf, "#<frame-part %lx>", VPART(win)->id);
+    rep_stream_puts (stream, buf, -1, FALSE);
+}
+
+static void
+fp_mark (repv obj)
+{
+    struct frame_part *fp;
+    for (fp = VPART(obj); fp != 0; fp = fp->next)
+    {
+	int i;
+	rep_MARKVAL(fp->alist);
+	rep_MARKVAL(fp->local_alist);
+	rep_MARKVAL(rep_VAL(fp->win));
+	for (i = 0; i < fps_MAX; i++)
+	{
+	    rep_MARKVAL(fp->font[i]);
+	    rep_MARKVAL(fp->fg[i]);
+	    rep_MARKVAL(fp->bg[i]);
+	}
+	rep_MARKVAL(rep_VAL(fp->cursor));
+	rep_MARKVAL(rep_VAL(fp->renderer));
+	rep_MARKVAL(rep_VAL(fp->rendered_image));
+	rep_MARKVAL(fp->drawn.font);
+	rep_MARKVAL(fp->drawn.text);
+	rep_MARKVAL(fp->drawn.x_justify);
+	rep_MARKVAL(fp->drawn.y_justify);
+	rep_MARKVAL(fp->drawn.fg);
+	rep_MARKVAL(fp->drawn.bg);
+    }
+}
+
+static void
+fp_sweep (void)
+{
+    struct frame_part *fp = allocated_parts;
+    allocated_parts = 0;
+    while (fp != 0)
+    {
+	struct frame_part *next = fp->next_alloc;
+	if (!rep_GC_CELL_MARKEDP(rep_VAL(fp)))
+	{
+	    assert (fp->next == 0);
+	    assert (fp->id == 0);
+#if 0
+	    /* XXX This assertion has been reported to trigger (when opening
+	       ddd and acroread -- both motif apps?). I don't see how this
+	       happens but since fp->id is zero and fp->win will get gc'd,
+	       we're not going to leak any resources, so.. */
+	    assert (fp->win == 0);
+#endif
+	    rep_FREE_CELL(fp);
+	}
+	else
+	{
+	    fp->next_alloc = allocated_parts;
+	    allocated_parts = fp;
+	    rep_GC_CLR_CELL(rep_VAL(fp));
+	}
+	fp = next;
+    }
+}
+
+
+/* building frames from component lists
+
+   build the frame from the list of components. Each element
+   in the list is an alist representing one component of the
+   frame, possible tags include:
+
+	class . SYMBOL
+
+	background . IMAGE-OR-COLOR
+	background . (NORMAL FOCUSED HIGHLIGHTED CLICKED)
+	background . ((STATE . VALUE) ...)
+	foreground . COLOR
+	foreground . (NORMAL FOCUSED HIGHLIGHTED CLICKED)
+	foreground . ((STATE . VALUE) ...)
+
+	renderer . FUNCTION
+	render-scale . INTEGER
+
+	text . STRING-OR-FUNCTION-OR-NIL
+	x-justify . left OR right OR center OR NUMBER
+	y-justify . top OR bottom OR center OR NUMBER
+
+	font . FONT
+	font . (NORMAL FOCUSED HIGHLIGHTED CLICKED)
+	font . ((STATE . FONT) ...)
+
+	left-edge . POSITION-REL-LEFT
+	right-edge . POSITION-REL-RIGHT
+	top-edge . POSITION-REL-TOP
+	bottom-edge . POSITION-REL-BOTTOM
+	height . PIXELS
+	width . PIXELS
+
+	keymap . KEYMAP
+	cursor . CURSOR-OR-CURSOR-DEF
+
+	below-client . t
+	scale-foreground . t
+
+   STATE's are one of: inactive, focused, highlighted, clicked,
+   inactive-highlighted, inactive-clicked.
+
+   Note that all numeric quantities may be defined dynamically by
+   substituting a function */
+
+int
+current_state (struct frame_part *fp)
+{
+    if (fp->clicked)
+    {
+	if (fp->win == focus_window)
+	    return fps_clicked;
+	else
+	    return fps_inactive_clicked;
+    }
+    else if (fp->highlighted)
+    {
+	if (fp->win == focus_window)
+	    return fps_highlighted;
+	else
+	    return fps_inactive_highlighted;
+    }
+    else if (fp->win == focus_window)
+	return fps_focused;
+    else
+	return fps_inactive;
+}
+
+/* Call FUN (ARG) with error protection in place. If an error occurs
+   a message is printed, and ERROR-RETURN is returned, else just return
+   the result of calling FUN. */
+static repv
+call_protectedly (repv (*fun)(repv), repv arg, repv error_return)
+{
+    rep_GC_root gc_error_return;
+    repv result;
+    rep_PUSHGC (gc_error_return, error_return);
+    result = fun (arg);
+    if (result == rep_NULL)
+    {
+	repv throw = rep_throw_value, stream;
+	rep_throw_value = rep_NULL;
+        stream = Fstderr_file();
+        if (stream != rep_NULL)
+        {
+	    rep_stream_puts (stream, "frame error: ", -1, rep_FALSE);
+	    if (rep_CAR (throw) == Qerror)
+		throw = rep_CDR (throw);
+            rep_print_val (stream, throw);
+            rep_stream_putc (stream, '\n');
+        }
+	result = error_return;
+    }
+    rep_POPGC;
+    return result;
+}
+
+/* Call lisp function FUN with the single arg ARG, with error protection */
+static repv
+call_protectedly_1 (repv fun, repv arg, repv error_return)
+{
+    return call_protectedly (Ffuncall, rep_LIST_2 (fun, arg), error_return);
+}
+
+static void
+apply_mask (Drawable dest, int x_off, int y_off,
+	    int dest_width, int dest_height,
+	    Pixmap src, int src_width, int src_height)
+{
+    if (dest_width - x_off >= src_width
+	&& dest_height - y_off >= src_height)
+    {
+	/* No need for a temporary buffer */
+	XShapeCombineMask (dpy, dest, ShapeBounding,
+			   x_off, y_off, src, ShapeUnion);
+    }
+    else
+    {
+	Pixmap tem = XCreatePixmap (dpy, src, dest_width - x_off,
+				    dest_height - y_off, 1);
+	XGCValues gcv;
+	GC gc = XCreateGC (dpy, tem, 0, &gcv);
+	XCopyArea (dpy, src, tem, gc, 0, 0,
+		   dest_width - x_off, dest_height - y_off, 0, 0);
+	XShapeCombineMask (dpy, dest, ShapeBounding,
+			   x_off, y_off, tem, ShapeUnion);
+	XFreeGC (dpy, gc);
+	XFreePixmap (dpy, tem);
+    }
+}
+
+/* Construct the frame window's shape mask from the union of all
+   individual shapes (frame parts and the client window, if appropriate).
+   If ATOMIC is true, then the frame shape is changed _once_ only, using
+   a temporary buffer to construct the new shape, then copying it
+   to the frame. */
+void
+set_frame_shapes (Lisp_Window *w, bool atomic)
+{
+    Window shape_win;
+    int nrects, nparts;
+    XRectangle *rects;
+    struct frame_part *fp;
+
+    if (atomic)
+    {
+	XSetWindowAttributes wa;
+	int wamask;
+	wa.colormap = image_cmap;
+	wa.border_pixel = BlackPixel (dpy, screen_num);
+	wamask = CWColormap | CWBorderPixel;
+	shape_win = XCreateWindow (dpy, root_window, -100, -100,
+				   w->frame_width, w->frame_height,
+				   0, image_depth, InputOutput,
+				   image_visual, wamask, &wa);
+    }
+    else
+	shape_win = w->frame;
+
+    nparts = 0;
+    for (fp = w->frame_parts; fp != 0; fp = fp->next)
+	nparts++;
+    nrects = 0;
+    rects = alloca (sizeof (XRectangle) * (nparts + 1));
+
+    rects[0].x = rects[0].y = 0;
+    rects[0].width = w->frame_width;
+    rects[0].height = w->frame_height;
+    XShapeCombineRectangles (dpy, shape_win, ShapeBounding,
+			     0, 0, rects, 1, ShapeSubtract, Unsorted);
+
+    if (!w->client_hidden)
+    {
+	if (w->shaped)
+	{
+	    XShapeCombineShape (dpy, shape_win, ShapeBounding,
+				-w->frame_x, -w->frame_y, w->id,
+				ShapeBounding, ShapeSet);
+	}
+	else
+	{
+	    rects[nrects].x = -w->frame_x;
+	    rects[nrects].y = -w->frame_y;
+	    rects[nrects].width = w->attr.width;
+	    rects[nrects].height = w->attr.height;
+	    nrects++;
+	}
+    }
+
+    for (fp = w->frame_parts; fp != 0 && !WINDOW_IS_GONE_P (w); fp = fp->next)
+    {
+	Pixmap pixmap, mask;
+	int state = current_state (fp);
+
+	if (fp->width <= 0 || fp->height <= 0)
+	    continue;
+
+	if (IMAGEP(fp->bg[state]))
+	{
+	    bool tiled = FALSE;
+	    Lisp_Image *image = VIMAGE(fp->bg[state]);
+	    repv tem;
+
+	    tem = Fimage_get (rep_VAL(image), Qtiled);
+	    if (tem && tem != Qnil)
+		tiled = TRUE;
+
+	    if (tiled)
+	    {
+		image_render (image, image_width (image), image_height (image),
+			      &pixmap, &mask);
+	    }
+	    else
+	    {
+		image_render (image, fp->width, fp->height, &pixmap, &mask);
+	    }
+
+	    if (mask != 0)
+	    {
+		int width = !tiled ? fp->width : image_width (image);
+		int height = !tiled ? fp->height : image_height (image);
+		int x_off = fp->x - w->frame_x;
+		int y_off = fp->y - w->frame_y;
+
+		apply_mask (shape_win, x_off, y_off,
+			    x_off + fp->width, y_off + fp->height,
+			    mask, width, height);
+
+		if (tiled)
+		{
+		    int x = width, y = 0;
+		    while (y < fp->height)
+		    {
+			while (x < fp->width)
+			{
+			    apply_mask (shape_win, x_off + x, y_off + y,
+					x_off + fp->width, y_off + fp->height,
+					mask, width, height);
+			    x += width;
+			}
+			y += height;
+			x = 0;
+		    }
+		}
+	    }
+	    else
+	    {
+		rects[nrects].x = fp->x - w->frame_x;
+		rects[nrects].y = fp->y - w->frame_y;
+		rects[nrects].width = fp->width;
+		rects[nrects].height = fp->height;
+		nrects++;
+	    }
+	    image_free_pixmaps (image, pixmap, mask);
+	}
+	else
+	{
+	    rects[nrects].x = fp->x - w->frame_x;
+	    rects[nrects].y = fp->y - w->frame_y;
+	    rects[nrects].width = fp->width;
+	    rects[nrects].height = fp->height;
+	    nrects++;
+	}
+    }
+
+    if (nrects > 0)
+    {
+	XShapeCombineRectangles (dpy, shape_win, ShapeBounding, 0, 0, rects,
+				 nrects, ShapeUnion, Unsorted);
+    }
+
+    if (atomic)
+    {
+	XShapeCombineShape (dpy, w->frame, ShapeBounding,
+			    0, 0, shape_win, ShapeBounding, ShapeSet);
+	XDestroyWindow (dpy, shape_win);
+    }
+
+    w->pending_reshape = 0;
+}
+
+/* Queue an atomic reshape for the frame of W. It will happen sometime
+   in the near future. */
+void
+queue_reshape_frame (Lisp_Window *w)
+{
+    w->pending_reshape = 1;
+}
+
+void
+commit_queued_reshapes (void)
+{
+    Lisp_Window *w;
+    for (w = window_list; w != 0; w = w->next)
+    {
+	if (!WINDOW_IS_GONE_P (w) && w->pending_reshape)
+	    set_frame_shapes (w, TRUE);
+    }
+}
+
+/* Draw the background of the frame-part FP. This is either a solid color
+   or an image (scaled or tiled) */
+static void
+set_frame_part_bg (struct frame_part *fp)
+{
+    int state = current_state (fp);
+    repv bg = fp->bg[state];
+    Lisp_Window *win = fp->win;
+
+    if (fp->id == 0)
+	return;
+
+    if (fp->renderer != Qnil && IMAGEP(fp->rendered_image))
+    {
+	bg = fp->rendered_image;
+	if (fp->rendered_state != state)
+	{
+	    rep_call_lisp2 (fp->renderer, bg, state_syms[state]);
+	    fp->rendered_state = state;
+	}
+	fp->drawn.bg = Qnil;
+    }
+
+    if (WINDOW_IS_GONE_P (win))
+	return;
+
+    if (COLORP(bg))
+    {
+	if (bg != fp->drawn.bg)
+	{
+	    XGCValues gcv;
+	    gcv.foreground = VCOLOR(bg)->pixel;
+	    XChangeGC (dpy, fp->gc, GCForeground, &gcv);
+	    XFillRectangle (dpy, fp->id, fp->gc, 0, 0, fp->width, fp->height);
+	    fp->drawn.bg = bg;
+	    fp->drawn.fg = rep_NULL;
+	}
+    }
+    else if (IMAGEP(bg))
+    {
+	Lisp_Image *image = VIMAGE(bg);
+	Pixmap bg_pixmap, bg_mask;
+	bool tiled = FALSE;
+	repv tem;
+
+	if (fp->drawn.bg == bg)
+	    return;
+
+	tem = Fimage_get (rep_VAL(image), Qtiled);
+	if (tem && tem != Qnil)
+	    tiled = TRUE;
+
+	if (tiled)
+	{
+	    image_render (image, image_width (image), image_height (image),
+			  &bg_pixmap, &bg_mask);
+	}
+	else
+	{
+	    image_render (image, fp->width, fp->height, &bg_pixmap, &bg_mask);
+	}
+
+	/* Some of the Imlib_ functions call XSync on our display. In turn
+	   this can cause the error handler to run if a window has been
+	   deleted. This then invalidates the window we're updating */
+	if (WINDOW_IS_GONE_P (win))
+	    return;
+
+	if (bg_mask == 0)
+	{
+	    /* No mask, so we always want to force the rectangle
+	       including the frame part to be shown.. */
+	    XRectangle rect;
+	    rect.x = rect.y = 0;
+	    rect.width = fp->width;
+	    rect.height = fp->height;
+	    XShapeCombineRectangles (dpy, fp->id, ShapeBounding,
+				     0, 0, &rect, 1, ShapeSet, Unsorted);
+	}
+
+	if (!tiled)
+	{
+	    XCopyArea (dpy, bg_pixmap, fp->id, fp->gc, 0, 0,
+		       fp->width, fp->height, 0, 0);
+	    if (bg_mask != 0)
+	    {
+		XShapeCombineMask (dpy, fp->id, ShapeBounding,
+				   0, 0, bg_mask, ShapeSet);
+	    }
+	}
+	else
+	{
+	    Window tem = 0;
+	    int y = 0;
+	    if (bg_mask != 0)
+	    {
+		XRectangle rect;
+		XSetWindowAttributes wa;
+		int wamask;
+		wa.colormap = image_cmap;
+		wa.border_pixel = BlackPixel (dpy, screen_num);
+		wamask = CWColormap | CWBorderPixel;
+		tem = XCreateWindow (dpy, win->frame, -100, -100,
+				     fp->width, fp->height,
+				     0, image_depth, InputOutput,
+				     image_visual, wamask, &wa);
+		rect.x = rect.y = 0;
+		rect.width = fp->width;
+		rect.height = fp->height;
+		XShapeCombineRectangles (dpy, tem, ShapeBounding, 0, 0,
+					 &rect, 1, ShapeSubtract, Unsorted);
+	    }
+	    while (y < fp->height)
+	    {
+		int x = 0;
+		int width = image_width (image);
+		int height = image_height (image);
+		while (x < fp->width)
+		{
+		    XCopyArea (dpy, bg_pixmap, fp->id, fp->gc,
+			       0, 0, width, height, x, y);
+		    if (bg_mask != 0)
+		    {
+			XShapeCombineMask (dpy, tem, ShapeBounding,
+					   x, y, bg_mask, ShapeUnion);
+		    }
+		    x += width;
+		}
+		y += height;
+	    }
+	    if (bg_mask != 0)
+	    {
+		XShapeCombineShape (dpy, fp->id, ShapeBounding, 0, 0,
+				    tem, ShapeBounding, ShapeSet);
+		XDestroyWindow (dpy, tem);
+	    }
+	}
+	image_free_pixmaps (image, bg_pixmap, bg_mask);
+
+	/* Imlib sometimes calls XSync (), which could hide events
+	   from select () */
+	rep_mark_input_pending (ConnectionNumber(dpy));
+
+	fp->drawn.bg = bg;
+	fp->drawn.fg = rep_NULL;
+
+	queue_reshape_frame (fp->win);
+    }
+    else if (Ffunctionp (bg) != Qnil)
+    {
+	rep_call_lisp1 (bg, rep_VAL(fp));
+	fp->drawn.bg = bg;
+	fp->drawn.fg = rep_NULL;
+    }
+    else
+	fp->drawn.bg = Qnil;
+}
+
+/* Draw the foreground pixels in frame-part FP. */
+static void
+set_frame_part_fg (struct frame_part *fp)
+{
+    int state = current_state (fp);
+    repv font = fp->font[state], fg = fp->fg[state];
+    XGCValues gcv;
+    u_long gcv_mask = 0;
+    repv string = rep_NULL;
+    int length = 0, width, height, x, y;
+    Lisp_Window *win = fp->win;
+
+    if (fp->id == 0)
+	return;
+
+    if (fg != Qnil && Ffunctionp (fg) != Qnil)
+    {
+	rep_call_lisp1 (fg, rep_VAL(fp));
+    }
+    else if (IMAGEP(fg) || fp->text != Qnil)
+    {
+	if (!COLORP(fg) && !IMAGEP(fg))
+	    fg = global_symbol_value (Qdefault_foreground);
+	if (!FONTP(font))
+	{
+	    font = global_symbol_value (Qdefault_font);
+	    if (!FONTP(font))
+		goto out;
+	}
+
+	if (IMAGEP(fg))
+	{
+	    if (fp->scale_foreground)
+	    {
+		width = fp->width;
+		height = fp->height;
+	    }
+	    else
+	    {
+		width = image_width (VIMAGE(fg));
+		height = image_height (VIMAGE(fg));
+	    }
+	}
+	else
+	{
+	    if (rep_STRINGP(fp->text))
+	    {
+		string = fp->text;
+		length = rep_STRING_LEN(fp->text);
+	    }
+	    else
+	    {
+		repv result = rep_call_lisp1 (fp->text, rep_VAL(fp->win));
+		if (!result || !rep_STRINGP(result))
+		    return;
+		string = result;
+		length = rep_STRING_LEN(result);
+	    }
+
+	    width = x_text_width (font, rep_STR(string), length);
+	    height = VFONT(font)->ascent + VFONT(font)->descent;
+	}
+
+	if (fp->x_justify == Qcenter)
+	    x = MAX(0, (fp->width - width) / 2);
+	else if (fp->x_justify == Qright)
+	    x = MAX(0, fp->width - width);
+	else if (rep_INTP(fp->x_justify))
+	{
+	    x = rep_INT(fp->x_justify);
+	    if (x < 0)
+		x = MAX(0, fp->width + x - width);
+	}
+	else
+	    x = 0;
+
+	if (fp->y_justify == Qcenter)
+	    y = MAX(0, (fp->height - height) / 2);
+	else if (fp->y_justify == Qbottom)
+	    y = MAX(0, fp->height - height);
+	else if (rep_INTP(fp->y_justify))
+	{
+	    y = rep_INT(fp->y_justify);
+	    if (y < 0)
+		y = MAX(0, fp->height + y - height);
+	}
+	else
+	    y = 0;
+
+	if (IMAGEP(fg))
+	{
+	    Pixmap fg_pixmap, fg_mask;
+
+	    if (fp->drawn.fg == fg
+		&& fp->drawn.x_justify == fp->x_justify
+		&& fp->drawn.y_justify == fp->y_justify)
+	    {
+		return;
+	    }
+	    else if (fp->drawn.fg != rep_NULL)
+	    {
+		/* there's something drawn in this part already,
+		   update the background to clear it */
+		fp->drawn.bg = rep_NULL;
+		set_frame_part_bg (fp);
+	    }
+
+	    image_render (VIMAGE(fg), width, height,
+			  &fg_pixmap, &fg_mask);
+
+	    /* Some of the Imlib_ functions call XSync on our display. In turn
+	       this can cause the error handler to run if a window has been
+	       deleted. This then invalidates the window we're updating */
+	    if (WINDOW_IS_GONE_P (win))
+		return;
+
+	    if (fg_pixmap)
+	    {
+		if (fg_mask)
+		{
+		    gcv.clip_mask = fg_mask;
+		    gcv.clip_x_origin = x;
+		    gcv.clip_y_origin = y;
+		    gcv_mask |= GCClipMask | GCClipXOrigin | GCClipYOrigin;
+		}
+
+		XChangeGC (dpy, fp->gc, gcv_mask, &gcv);
+		XCopyArea (dpy, fg_pixmap, fp->id, fp->gc,
+			   0, 0, MIN(fp->width, width),
+			   MIN(fp->height, height), x, y);
+		if (fg_mask)
+		{
+		    gcv.clip_mask = None;
+		    gcv.clip_x_origin = 0;
+		    gcv.clip_y_origin = 0;
+		    XChangeGC (dpy, fp->gc, GCClipMask | GCClipXOrigin
+			       | GCClipYOrigin, &gcv);
+		}
+		image_free_pixmaps (VIMAGE(fg), fg_pixmap, fg_mask);
+	    }
+	    /* Imlib sometimes calls XSync (), which could hide events
+	       from select () */
+	    rep_mark_input_pending (ConnectionNumber(dpy));
+
+	    fp->drawn.text = Qnil;
+	}
+	else if (COLORP(fg) && FONTP(font))
+	{
+	    if ((fp->drawn.text == string
+		 || Fequal (fp->drawn.text, string) != Qnil)
+		&& fp->drawn.font == font && fp->drawn.fg == fg
+		&& fp->drawn.x_justify == fp->x_justify
+		&& fp->drawn.y_justify == fp->y_justify)
+	    {
+		return;
+	    }
+ 	    else if (fp->drawn.fg != rep_NULL)
+	    {
+		/* there's something drawn in this part already,
+		   update the background to clear it */
+		fp->drawn.bg = rep_NULL;
+		set_frame_part_bg (fp);
+	    }
+
+	    if (COLORP(fg))
+	    {
+		gcv.foreground = VCOLOR(fg)->pixel;
+		gcv_mask |= GCForeground;
+	    }
+
+	    XChangeGC (dpy, fp->gc, gcv_mask, &gcv);
+	    x_draw_string (fp->id, font, fp->gc, x, y + VFONT(font)->ascent,
+			   rep_STR(string), length);
+
+	    fp->drawn.text = string;
+	}
+    }
+out:
+    fp->drawn.font = font;
+    fp->drawn.fg = fg;
+    fp->drawn.x_justify = fp->x_justify;
+    fp->drawn.y_justify = fp->y_justify;
+}
+
+/* Redraw FP. */
+void
+refresh_frame_part (struct frame_part *fp)
+{
+    if (!frame_draw_mutex)
+    {
+	Lisp_Window *w = fp->win;
+	if (w == 0)			/* XXX why is this needed? */
+	    return;
+
+	if (fp->drawn.width != fp->width || fp->drawn.height != fp->height)
+	    fp->drawn.bg = rep_NULL;
+
+	if (!WINDOW_IS_GONE_P (w) && fp->id != 0)
+	    set_frame_part_bg (fp);
+	if (!WINDOW_IS_GONE_P (w) && fp->id != 0)
+	    set_frame_part_fg (fp);
+
+	fp->drawn.width = fp->width;
+	fp->drawn.height = fp->height;
+	fp->pending_refresh = 0;
+    }
+    else
+	fp->pending_refresh = 1;
+}
+
+/* Redraw frame parts in W. */
+void
+refresh_frame_parts (Lisp_Window *w)
+{
+    struct frame_part *fp;
+    for (fp = w->frame_parts; !WINDOW_IS_GONE_P (w) && fp != 0; fp = fp->next)
+	refresh_frame_part (fp);
+}
+
+/* Find the frame-part that is drawn in window ID */
+struct frame_part *
+find_frame_part_by_window (Window id)
+{
+    struct frame_part *fp;
+    return XFindContext (dpy, id, window_fp_context, (XPointer *)&fp) ? 0 : fp;
+}
+
+/* Destroy the window frame of W, assuming it's a frame-part derived frame */
+static void
+frame_part_destroyer (Lisp_Window *w)
+{
+    struct frame_part *fp, *next;
+    for (fp = w->frame_parts; fp != 0; fp = next)
+    {
+	if (fp->clicked)
+	{
+	    /* This is necessary so that clicked_frame_part is cleared. */
+	    bool old_mutex = frame_draw_mutex;
+	    frame_draw_mutex = TRUE;
+	    unclick_current_fp ();
+	    XUngrabPointer (dpy, last_event_time);
+	    frame_draw_mutex = old_mutex;
+	}
+
+	if (fp->gc)
+	{
+	    XFreeGC (dpy, fp->gc);
+	    fp->gc = 0;
+	}
+
+	if (fp->id != 0)
+	{
+	    XDeleteContext (dpy, fp->id, window_fp_context);
+	    XDestroyWindow (dpy, fp->id);
+	    fp->id = 0;
+	}
+
+	fp->win = 0;
+	next = fp->next;
+	fp->next = 0;
+    }
+    w->frame_parts = 0;
+}
+
+/* Handle the expose event EV for the frame part FP. */
+void
+frame_part_exposer (XExposeEvent *ev, struct frame_part *fp)
+{
+    if (ev->count == 0)
+    {
+	/* expose events override the drawing mutex,
+	   unless the server is grabbed.. */
+	bool old_mutex = frame_draw_mutex;
+	frame_draw_mutex = (Fserver_grabbed_p () != Qnil);
+	fp->drawn.bg = rep_NULL;
+	refresh_frame_part (fp);
+	frame_draw_mutex = old_mutex;
+    }
+}
+
+static repv
+fp_assq (struct frame_part *fp, repv prop,
+	 repv class_alist, repv ov_class_alist)
+{
+    repv tem;
+
+    tem = Fassq (prop, fp->local_alist);
+    if (tem && tem != Qnil)
+	return tem;
+
+    tem = Fassq (prop, ov_class_alist);
+    if (tem && tem != Qnil)
+	return tem;
+
+    tem = Fassq (prop, fp->alist);
+    if (tem && tem != Qnil)
+	return tem;
+
+    tem = Fassq (prop, class_alist);
+    if (tem && tem != Qnil)
+	return tem;
+    
+    return Qnil;
+}
+
+static repv
+x_fp_assq (struct frame_part *fp, repv prop)
+{
+    repv ret = Qnil, class, tem;
+
+    ret = Fassq (prop, fp->local_alist);
+    if (ret && ret != Qnil)
+	return ret;
+
+    class = Fassq (Qclass, fp->alist);
+    if (class && class != Qnil)
+	class = rep_CDR(class);
+    else
+	class = rep_NULL;
+
+    tem = global_symbol_value (Qoverride_frame_part_classes);
+    if (class != rep_NULL && rep_CONSP(tem))
+    {
+	tem = Fassq (class, tem);
+	if (tem && tem != Qnil)
+	    ret = Fassq (prop, rep_CDR(tem));
+    }
+
+    if (ret && ret == Qnil)
+	ret = Fassq (prop, fp->alist);
+
+    if (ret && ret == Qnil)
+    {
+	tem = global_symbol_value (Qframe_part_classes);
+	if (class != rep_NULL && rep_CONSP(tem))
+	{
+	    tem = Fassq (class, tem);
+	    if (tem && tem != Qnil)
+		ret = Fassq (prop, rep_CDR(tem));
+	}
+    }
+
+    return ret ? ret : Qnil;
+}
+
+static repv
+get_integer_prop (struct frame_part *fp, repv prop, repv class, repv ov_class)
+{
+    repv tem = fp_assq (fp, prop, class, ov_class);
+    if (tem && tem != Qnil)
+    {
+	if (rep_INTP(rep_CDR(tem)))
+	    tem = rep_CDR(tem);
+	else
+	    tem = call_protectedly_1 (rep_CDR(tem), rep_VAL(fp->win), Qnil);
+	return rep_INTP(tem) ? tem : Qnil;
+    }
+    else
+	return Qnil;
+}
+
+static repv
+get_boolean_prop (struct frame_part *fp, repv prop, repv class, repv ov_class)
+{
+    repv tem = fp_assq (fp, prop, class, ov_class);
+    if (tem && tem != Qnil)
+    {
+	if (Ffunctionp (rep_CDR(tem)) == Qnil)
+	    tem = rep_CDR(tem);
+	else
+	    tem = call_protectedly_1 (rep_CDR(tem), rep_VAL(fp->win), Qnil);
+	return tem;
+    }
+    else
+	return Qnil;
+}
+
+static bool
+get_pattern_prop (struct frame_part *fp, repv *data, repv (*conv)(repv data),
+		  repv prop, repv class, repv ov_class)
+{
+    int i;
+    repv tem;
+
+    tem = fp_assq (fp, prop, class, ov_class);
+    if (tem != Qnil)
+    {
+	if (Ffunctionp (rep_CDR(tem)) != Qnil)
+	    tem = call_protectedly_1 (rep_CDR(tem), rep_VAL(fp->win), Qnil);
+	else
+	    tem = rep_CDR(tem);
+	if (!rep_CONSP(tem))
+	{
+	    /* single value pattern */
+	    data[0] = tem;
+	    for (i = 1; i < fps_MAX; i++)
+		data[i] = data[0];
+	}
+	else if (!rep_CONSP(rep_CAR(tem)))
+	{
+	    /* list of four elements: (NORMAL FOCUSED HIGHLIGHTED CLICKED) */
+
+	    static int map[4] = {
+		fps_inactive, fps_focused, fps_highlighted, fps_clicked
+	    };
+
+	    for (i = 0; i < 4; i++)
+	    {
+		data[map[i]] = rep_CAR(tem);
+		if (rep_CONSP(rep_CDR(tem)))
+		    tem = rep_CDR(tem);
+	    }
+	}
+	else
+	{
+	    /* alist of elements (STATE . VALUE) */
+
+	    while (rep_CONSP(tem) && rep_CONSP(rep_CAR(tem)))
+	    {
+		repv state = rep_CAR(rep_CAR(tem));
+		int idx = fps_none;
+
+		if (state == Qinactive)
+		    idx = fps_inactive;
+		else if (state == Qfocused)
+		    idx = fps_focused;
+		else if (state == Qhighlighted)
+		    idx = fps_highlighted;
+		else if (state == Qclicked)
+		    idx = fps_clicked;
+		else if (state == Qinactive_highlighted)
+		    idx = fps_inactive_highlighted;
+		else if (state == Qinactive_clicked)
+		    idx = fps_inactive_clicked;
+		if (idx != fps_none)
+		    data[idx] = rep_CDR(rep_CAR(tem));
+
+		tem = rep_CDR(tem);
+	    }
+	}
+
+	/* now handle string conversions */
+	for (i = 0; i < fps_MAX; i++)
+	{
+	    if (rep_STRINGP(data[i]))
+		data[i] = call_protectedly (conv, data[i], Qnil);
+	}
+
+	/* now fill any gaps in the state table */
+	for (i = 0; i < fps_MAX; i++)
+	{
+	    static int map[fps_MAX] = {
+		fps_inactive, fps_inactive, fps_focused,
+		fps_inactive, fps_highlighted, fps_inactive_highlighted
+	    };
+
+	    if (data[i] == Qnil)
+		data[i] = data[map[i]];
+	}
+    }
+    return TRUE;
+}
+
+static bool
+build_frame_part (struct frame_part *fp)
+{
+    Lisp_Window *w = fp->win;
+    repv class = Qnil, class_elt = Qnil, ov_class_elt = Qnil, tem;
+    rep_GC_root gc_class, gc_class_elt, gc_ov_class_elt;
+    bool had_left_edge = FALSE, had_top_edge = FALSE;
+    bool had_right_edge = FALSE, had_bottom_edge = FALSE;
+    bool ret = FALSE;
+    int i;
+
+    rep_PUSHGC(gc_class, class);
+    rep_PUSHGC(gc_class_elt, class_elt);
+    rep_PUSHGC(gc_ov_class_elt, ov_class_elt);
+
+    fp->width = fp->height = -1;
+    for (i = 0; i < fps_MAX; i++)
+	fp->fg[i] = fp->bg[i] = fp->font[i] = Qnil;
+
+    /* find the class of the part, and the alists of class-local state */
+    tem = Fassq (Qclass, fp->alist);
+    if (tem && tem != Qnil)
+    {
+	class = rep_CDR(tem);
+	tem = global_symbol_value (Qframe_part_classes);
+	if (rep_CONSP(tem))
+	{
+	    tem = Fassq (class, tem);
+	    if (tem && tem != Qnil)
+		class_elt = rep_CDR(tem);
+	}
+	tem = global_symbol_value (Qoverride_frame_part_classes);
+	if (rep_CONSP(tem))
+	{
+	    tem = Fassq (class, tem);
+	    if (tem && tem != Qnil)
+		ov_class_elt = rep_CDR(tem);
+	}
+    }
+
+    /* do we ignore this part? */
+    tem = get_boolean_prop (fp, Qhidden, class_elt, ov_class_elt);
+    if (tem != Qnil)
+	goto next_part;
+    tem = Fassq (Qremovable, fp->alist);
+    if (tem && tem != Qnil && rep_CDR(tem) != Qnil)
+    {
+	tem = Fwindow_get (rep_VAL(w), Qremoved_classes);	/* XXX hoist */
+	if (tem && rep_CONSP(tem))
+	{
+	    tem = Fmemq (class, tem);
+	    if (tem && tem != Qnil)
+		goto next_part;
+	}
+    }
+
+    tem = get_boolean_prop (fp, Qbelow_client, class_elt, ov_class_elt);
+    fp->below_client = (tem && tem != Qnil);
+    tem = get_boolean_prop (fp, Qscale_foreground, class_elt, ov_class_elt);
+    fp->scale_foreground = (tem && tem != Qnil);
+
+    /* get text label */
+    tem = fp_assq (fp, Qtext, class_elt, ov_class_elt);
+    if (tem != Qnil)
+	fp->text = rep_CDR(tem);
+    else
+	fp->text = Qnil;
+    tem = fp_assq (fp, Qx_justify, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	tem = rep_CDR(tem);
+	if (Ffunctionp (tem) != Qnil)
+	    tem = call_protectedly_1 (tem, rep_VAL(w), Qnil);
+	fp->x_justify = tem;
+    }
+    else
+	fp->x_justify = Qnil;
+    tem = fp_assq (fp, Qy_justify, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	tem = rep_CDR(tem);
+	if (Ffunctionp (tem) != Qnil)
+	    tem = call_protectedly_1 (tem, rep_VAL(w), Qnil);
+	fp->y_justify = tem;
+    }
+    else
+	fp->y_justify = Qnil;
+
+    /* get cursor */
+    fp->cursor = Qnil;
+    tem = fp_assq (fp, Qcursor, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	tem = rep_CDR(tem);
+	if (Ffunctionp (tem) != Qnil)
+	    tem = call_protectedly_1 (tem, rep_VAL (w), Qnil);
+	if (!CURSORP(tem) && tem != Qnil)
+	    tem = call_protectedly (Fget_cursor, tem, Qnil);
+	if (CURSORP(tem))
+	    fp->cursor = tem;
+    }
+
+    /* get renderer function */
+    tem = fp_assq (fp, Qrenderer, class_elt, ov_class_elt);
+    if (tem != Qnil && Ffunctionp (rep_CDR(tem)) != Qnil)
+    {
+	fp->renderer = rep_CDR(tem);
+	tem = get_integer_prop (fp, Qrender_scale, class_elt, ov_class_elt);
+	if (tem != Qnil && rep_INT(tem) > 0)
+	    fp->render_scale = rep_INT(tem);
+	else
+	    fp->render_scale = 1;
+    }
+    else
+	fp->renderer = Qnil;
+
+    /* get background images or colors */
+    if (!get_pattern_prop (fp, fp->bg, Fget_color,
+			   Qbackground, class_elt, ov_class_elt))
+    {
+	goto next_part;
+    }
+
+    /* get foreground colors or images */
+    if (!get_pattern_prop (fp, fp->fg, Fget_color,
+			   Qforeground, class_elt, ov_class_elt))
+    {
+	goto next_part;
+    }
+
+    /* get fonts */
+    if (!get_pattern_prop (fp, fp->font, Fget_font,
+			   Qfont, class_elt, ov_class_elt))
+    {
+	goto next_part;
+    }
+
+    /* If we have a background image for this part, take it as
+       the provisional dimensions of the part */
+    for (i = 0; i < fps_MAX; i++)
+    {
+	if (IMAGEP(fp->bg[i]))
+	{
+	    fp->width = image_width (VIMAGE(fp->bg[i]));
+	    fp->height = image_height (VIMAGE(fp->bg[i]));
+	    break;
+	}
+    }
+
+    /* get dimensions.. */
+    tem = get_integer_prop (fp, Qwidth, class_elt, ov_class_elt);
+    if (tem != Qnil)
+	fp->width = rep_INT(tem);
+    tem = get_integer_prop (fp, Qheight, class_elt, ov_class_elt);
+    if (tem != Qnil)
+	fp->height = rep_INT(tem);
+    tem = get_integer_prop (fp, Qleft_edge, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	fp->x = rep_INT(tem);
+	had_left_edge = TRUE;
+    }
+    tem = get_integer_prop (fp, Qtop_edge, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	fp->y = rep_INT(tem);
+	had_top_edge = TRUE;
+    }
+    tem = get_integer_prop (fp, Qright_edge, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	had_right_edge = TRUE;
+	if (had_left_edge)
+	    fp->width = w->attr.width - rep_INT(tem) - fp->x;
+	else
+	    fp->x = w->attr.width - rep_INT(tem) - fp->width;
+    }
+    tem = get_integer_prop (fp, Qbottom_edge, class_elt, ov_class_elt);
+    if (tem != Qnil)
+    {
+	had_bottom_edge = TRUE;
+	if (had_top_edge)
+	    fp->height = w->attr.height - rep_INT(tem) - fp->y;
+	else
+	    fp->y = w->attr.height - rep_INT(tem) - fp->height;
+    }
+
+    if (fp->width < 0)
+	fp->width = 0;
+    if (fp->height < 0)
+	fp->height = 0;
+
+    /* try to remove edges sticking out of small windows. if a part
+       specified by only one edge sticks out of the other edge, then
+       truncate it */
+
+    if (had_right_edge && !had_left_edge && fp->x < 0)
+    {
+	fp->width += fp->x;
+	fp->x = 0;
+    }
+    else if (had_left_edge && !had_right_edge
+	     && fp->x + fp->width > w->attr.width)
+    {
+	fp->width = w->attr.width - fp->x;
+    }
+
+    if (had_bottom_edge && !had_top_edge && fp->y < 0)
+    {
+	fp->height += fp->y;
+	fp->y = 0;
+    }
+    else if (had_top_edge && !had_bottom_edge
+	     && fp->y + fp->height > w->attr.height)
+    {
+	fp->height = w->attr.height - fp->y;
+    }
+
+    /* if we have a renderer function, create the image to
+       render into. */
+    if (fp->renderer != Qnil)
+    {
+	fp->rendered_image
+	     = Fmake_sized_image (rep_MAKE_INT(fp->width / fp->render_scale),
+				  rep_MAKE_INT(fp->height / fp->render_scale),
+				  Qnil);
+	fp->rendered_state = fps_none;
+    }
+    else
+	fp->rendered_image = Qnil;
+
+    DB(("  part: x=%d y=%d width=%d height=%d\n",
+	fp->x, fp->y, fp->width, fp->height));
+
+    ret = TRUE;
+
+next_part:
+    rep_POPGC; rep_POPGC; rep_POPGC;
+    return ret;
+}
+
+static void
+configure_frame_part (struct frame_part *fp)
+{
+    Lisp_Window *w = fp->win;
+    XSetWindowAttributes wa;
+    u_long wamask;
+    if (fp->id == 0)
+    {
+	if (fp->width > 0 && fp->height > 0)
+	{
+	    XGCValues gcv;
+	    wa.win_gravity = StaticGravity;
+	    wa.bit_gravity = StaticGravity;
+	    wa.colormap = image_cmap;
+	    wa.border_pixel = BlackPixel (dpy, screen_num);
+	    wamask = CWWinGravity | CWBitGravity | CWColormap | CWBorderPixel;
+	    fp->id = XCreateWindow (dpy, w->frame,
+				    fp->x - w->frame_x, fp->y - w->frame_y,
+				    fp->width, fp->height,
+				    0, image_depth, InputOutput,
+				    image_visual, wamask, &wa);
+	    fp->gc = XCreateGC (dpy, fp->id, 0, &gcv);
+	    XSelectInput (dpy, fp->id, FP_EVENTS);
+
+	    if (!fp->below_client)
+		XMapRaised (dpy, fp->id);
+	    else
+	    {
+		XMapWindow (dpy, fp->id);
+		XLowerWindow (dpy, fp->id);
+	    }
+
+	    /* stash the fp in the window */
+	    XSaveContext (dpy, fp->id, window_fp_context, (XPointer)fp);
+
+	    fp->drawn.fg = rep_NULL;
+	    fp->drawn.bg = rep_NULL;
+	}
+    }
+    else
+    {
+	if (fp->width > 0 && fp->height > 0)
+	{
+	    XWindowChanges attr;
+	    attr.x = fp->x - w->frame_x;
+	    attr.y = fp->y - w->frame_y;
+	    attr.width = fp->width;
+	    attr.height = fp->height;
+	    attr.stack_mode = fp->below_client ? Below : Above;
+	    XConfigureWindow (dpy, fp->id, CWX | CWY | CWWidth
+			      | CWHeight | CWStackMode, &attr);
+	    /* Generate an Expose event for the window. */
+	    XClearArea (dpy, fp->id, 0, 0, 0, 0, True);
+	}
+	else
+	{
+	    XDestroyWindow (dpy, fp->id);
+	    fp->id = 0;
+	    XFreeGC (dpy, fp->gc);
+	    fp->gc = 0;
+	}
+    }
+    if (fp->id != 0)
+    {
+	XDefineCursor (dpy, fp->id, (fp->cursor != Qnil)
+		       ? VCURSOR(fp->cursor)->cursor : None);
+    }
+}
+
+/* Generate a frame-part frame for window W. If called for a window that
+   already has a frame, it will be rebuilt to the current window size. */
+static void
+list_frame_generator (Lisp_Window *w)
+{
+    repv gen_list = w->frame_style;
+    repv ptr = rep_NULL, tem;
+    struct frame_part **last_fp = 0;
+    struct frame_part *fp = 0;
+    rep_GC_root gc_win, gc_ptr;
+    repv win = rep_VAL(w);
+    bool regen;				/* are we resizing the frame */
+    bool bigger;
+    int nparts = 0;
+    XSetWindowAttributes wa;
+    u_long wamask;
+    int old_x_off, old_y_off;
+
+    /* bounding box of frame */
+    int left_x, top_y, right_x, bottom_y;
+
+    tem = Fwindow_get (rep_VAL(w), Qhide_client);
+    if (tem && tem != Qnil)
+	w->client_hidden = 1;
+    else
+	w->client_hidden = 0;
+
+    left_x = top_y = 0;
+    if (!w->client_hidden)
+    {
+	right_x = w->attr.width;
+	bottom_y = w->attr.height;
+    }
+    else
+	right_x = bottom_y = 0;
+
+    DB(("list_frame_generator(%s)\n", rep_STR(w->name)));
+
+    while (gen_list != Qnil && rep_SYMBOLP(gen_list) && !rep_INTERRUPTP)
+    {
+	gen_list = Fsymbol_value (gen_list, Qt);
+	rep_TEST_INT;
+    }
+
+    rep_PUSHGC(gc_win, win);
+
+    /* construct the component list, and find the bounding box */
+
+    /* if w->destroy_frame is set then we're rebuilding an existing
+       frame */
+    if (w->destroy_frame == 0)
+    {
+	ptr = gen_list;
+	last_fp = &w->frame_parts;
+	assert (w->frame_parts == 0);
+	regen = FALSE;
+    }
+    else
+    {
+	fp = w->frame_parts;
+	regen = TRUE;
+    }
+
+    /* This loop is a bit weird. If we're building the frame from scratch
+       we loop over the Lisp list of frame part specs. Otherwise we loop
+       over the _actual_ list of frame parts */
+    rep_PUSHGC(gc_ptr, ptr);
+    while ((!regen && rep_CONSP(ptr))
+	   || (regen && fp != 0))
+    {
+	rep_GC_root gc_fp;
+	repv fp_;
+	if (!regen)
+	    fp = fp_new (w, rep_CAR (ptr));
+	fp_ = rep_VAL(fp);
+
+	rep_PUSHGC(gc_fp, fp_);
+	if (build_frame_part (fp))
+	{
+	    /* expand frame bounding box */
+	    left_x = MIN(left_x, fp->x);
+	    right_x = MAX(right_x, fp->x + fp->width);
+	    top_y = MIN(top_y, fp->y);
+	    bottom_y = MAX(bottom_y, fp->y + fp->height);
+
+	    if (!regen)
+	    {
+		/* link in fp */
+		*last_fp = fp;
+		last_fp = &fp->next;
+	    }
+
+	    nparts++;
+	}
+	rep_POPGC;			/* fp */
+
+	if (!regen)
+	    ptr = rep_CDR(ptr);
+	else
+	    fp = fp->next;
+    }
+    rep_POPGC;				/* ptr */
+
+    bigger = (right_x - left_x > w->frame_width
+	      || bottom_y - top_y > w->frame_height);
+
+    old_x_off = w->frame_x;
+    old_y_off = w->frame_y;
+
+    /* now we can find the size and offset of the frame. */
+    w->frame_width = right_x - left_x;
+    w->frame_height = bottom_y - top_y;
+    w->frame_x = left_x;
+    w->frame_y = top_y;
+
+    DB(("  bounding box: x=%d y=%d width=%d height=%d\n",
+	left_x, top_y, w->frame_width, w->frame_height));
+
+    if (w->reparented && bigger)
+	set_frame_shapes (w, TRUE);
+
+    /* create the child-of-root frame window, or if it already exists,
+       configure it to the correct size.. */
+    if (w->frame == 0)
+    {
+	/* create the frame */
+	wa.override_redirect = True;
+	wa.colormap = image_cmap;
+	wa.border_pixel = BlackPixel (dpy, screen_num);
+	wamask = CWOverrideRedirect | CWColormap | CWBorderPixel;
+	w->frame = XCreateWindow (dpy, root_window, w->attr.x, w->attr.y,
+				  w->frame_width, w->frame_height,
+				  0, image_depth, InputOutput,
+				  image_visual, wamask, &wa);
+    }
+    else
+    {
+	/* adjust frame position to keep absolute client position constant */
+	w->attr.x += w->frame_x - old_x_off;
+	w->attr.y += w->frame_y - old_y_off;
+
+	XMoveResizeWindow (dpy, w->frame, w->attr.x, w->attr.y,
+			   w->frame_width, w->frame_height);
+
+	if (w->reparented)
+	    XMoveResizeWindow (dpy, w->id, -left_x, -top_y,
+			       w->attr.width, w->attr.height);
+	else
+	    XResizeWindow (dpy, w->id, w->attr.width, w->attr.height);
+    }
+
+    w->destroy_frame = frame_part_destroyer;
+    w->focus_change = refresh_frame_parts;
+    w->rebuild_frame = list_frame_generator;
+    w->property_change = refresh_frame_parts;
+
+    if (w->reparented)
+	XLowerWindow (dpy, w->id);
+
+    /* create/update windows for each part */
+    for (fp = w->frame_parts; fp != 0; fp = fp->next)
+	configure_frame_part (fp);
+
+    if (!w->reparented || !bigger)
+	set_frame_shapes (w, TRUE);
+
+    /* ICCCM says we must unmap the client window when it's hidden */
+    {
+	int unmap_client = (!w->visible || w->client_hidden);
+	if (w->client_unmapped != unmap_client)
+	{
+	    before_local_map (w);
+	    if (unmap_client)
+		XUnmapWindow (dpy, w->id);
+	    else
+		XMapWindow (dpy, w->id);
+	    w->client_unmapped = unmap_client;
+	    after_local_map (w);
+	    if (focus_window == w)
+		focus_on_window (w);
+	}
+    }
+
+    rep_POPGC;				/* win */
+}
+
+/* Return the keymap associated with this frame part, or nil */
+repv
+get_keymap_for_frame_part (struct frame_part *fp)
+{
+    repv tem = x_fp_assq (fp, Qkeymap);
+    if (tem != Qnil)
+	tem = rep_CDR(tem);
+    return tem;
+}
+
+/* Mark all frame-parts of window W for gc. */
+void
+mark_frame_parts (Lisp_Window *w)
+{
+    struct frame_part *fp;
+    for (fp = w->frame_parts; fp != 0; fp = fp->next)
+	rep_MARKVAL (rep_VAL(fp));
+}
+
+/* Reset state of all frame parts in window W. */
+void
+reset_frame_parts (Lisp_Window *w)
+{
+    struct frame_part *fp;
+    for (fp = w->frame_parts; fp != 0; fp = fp->next)
+    {
+	int old_state = current_state (fp), new_state;
+	if (fp->clicked)
+	    unclick_current_fp ();
+	fp->highlighted = 0;
+	new_state = current_state (fp);
+	if (new_state != old_state)
+	    refresh_frame_part (fp);
+    }
+}
+
+/* Make sure stacking in frame is as desired after reparenting
+   the client into the frame */
+void
+restack_frame_parts (Lisp_Window *w)
+{
+    struct frame_part *fp;
+    XLowerWindow (dpy, w->id);
+    for (fp = w->frame_parts; fp != 0; fp = fp->next)
+    {
+	if (fp->id != 0 && fp->below_client)
+	    XLowerWindow (dpy, fp->id);
+    }
+}
+
+
+/* creating window frames */
+
+/* Create a frame for window W. Called with the server grabbed. If
+   w->frame is non-zero, then we'll use this window to construct the
+   frame in, otherwise w->frame will be initialised with a new window */
+void
+create_window_frame (Lisp_Window *w)
+{
+    DB(("create_window_frame (%s)\n", rep_STR(w->name)));
+    if (w->frame_parts == 0)
+    {
+	w->destroy_frame = 0;
+	w->focus_change = 0;
+	w->rebuild_frame = 0;
+	w->property_change = 0;
+	list_frame_generator (w);
+    }
+    else
+	fprintf (stderr, "warning: reframing framed window: %lx\n", (long) w->id);
+}
+
+/* Destroy the frame of window W. If LEAVE-FRAME-WIN is non-zero, then
+   w->frame won't be destroyed */
+void
+destroy_window_frame (Lisp_Window *w, bool leave_frame_win)
+{
+    if (w->frame != 0)
+    {
+	if (w->destroy_frame != 0)
+	{
+	    w->destroy_frame (w);
+	    w->destroy_frame = 0;
+	}
+	if (!leave_frame_win && w->frame != 0)
+	{
+	    XDestroyWindow (dpy, w->frame);
+	    w->frame = 0;
+	}
+    }
+}
+
+
+/* Lisp functions */
+
+DEFUN("frame-draw-mutex", Fframe_draw_mutex,
+      Sframe_draw_mutex, (repv arg), rep_Subr1) /*
+::doc:sawfish.wm.frames.subrs#frame-draw-mutex::
+While this variable is non-nil no frame parts will be redrawn. When it is
+set to nil any pending redraws will take place.
+::end:: */
+{
+    repv ret = frame_draw_mutex ? Qt : Qnil;
+    frame_draw_mutex = (arg != Qnil);
+    if (!frame_draw_mutex)
+    {
+	Lisp_Window *w;
+	for (w = window_list; w != 0; w = w->next)
+	{
+	    struct frame_part *fp;
+	    for (fp = w->frame_parts; fp != 0; fp = fp->next)
+	    {
+		if (fp->pending_refresh)
+		    refresh_frame_part (fp);
+	    }
+	}
+    }
+    return ret;
+}
+	
+DEFUN("frame-state-mutex", Fframe_state_mutex,
+      Sframe_state_mutex, (repv arg), rep_Subr1) /*
+::doc:sawfish.wm.frames.subrs#frame-state-mutex::
+While this variable is non-nil the state of frame parts will not be
+altered when the pointer enters or leaves its window.
+::end:: */
+{
+    repv ret = frame_state_mutex ? Qt : Qnil;
+    frame_state_mutex = (arg != Qnil);
+    if (arg == Qclicked
+	&& clicked_frame_part != 0
+	&& !clicked_frame_part->clicked)
+    {
+	/* XXX hack alert */
+	clicked_frame_part->clicked = 1;
+	refresh_frame_part (clicked_frame_part);
+    }
+    return ret;
+}
+
+DEFUN("frame-part-get", Fframe_part_get,
+      Sframe_part_get, (repv part, repv prop), rep_Subr2) /*
+::doc:sawfish.wm.frames.subrs#frame-part-get::
+frame-part-get PART PROPERTY
+::end:: */
+{
+    repv tem;
+    rep_DECLARE1 (part, PARTP);
+    rep_DECLARE2 (prop, rep_SYMBOLP);
+    tem = x_fp_assq (VPART(part), prop);
+    return (tem != Qnil) ? rep_CDR(tem) : Qnil;
+}
+
+DEFUN("frame-part-put", Fframe_part_put, Sframe_part_put,
+      (repv part, repv prop, repv value), rep_Subr3)
+{
+    repv tem;
+    rep_DECLARE1(part, PARTP);
+    rep_DECLARE2(prop, rep_SYMBOLP);
+    tem = Fassq (prop, VPART(part)->local_alist);
+    if (tem != rep_NULL)
+    {
+	if (tem != Qnil)
+	    rep_CDR (tem) = value;
+	else
+	    VPART(part)->local_alist = Fcons (Fcons (prop, value),
+					      VPART(part)->local_alist);
+    }
+    return value;
+}
+
+DEFUN("frame-part-window", Fframe_part_window,
+      Sframe_part_window, (repv part), rep_Subr1)
+{ 
+    rep_DECLARE1(part, PARTP);
+    return rep_VAL(VPART(part)->win);
+}
+
+DEFUN("frame-part-x-window", Fframe_part_x_window,
+      Sframe_part_x_window, (repv part), rep_Subr1)
+{ 
+    rep_DECLARE1(part, PARTP);
+    return VPART(part)->id != 0 ? rep_MAKE_INT(VPART(part)->id) : Qnil;
+}
+
+DEFUN("frame-part-position", Fframe_part_position,
+      Sframe_part_position, (repv part), rep_Subr1)
+{ 
+    rep_DECLARE1(part, PARTP);
+    return Fcons (rep_MAKE_INT(VPART(part)->x - VPART(part)->win->frame_x),
+		  rep_MAKE_INT(VPART(part)->y - VPART(part)->win->frame_y));
+}
+
+DEFUN("frame-part-dimensions", Fframe_part_dimensions,
+      Sframe_part_dimensions, (repv part), rep_Subr1)
+{ 
+    rep_DECLARE1(part, PARTP);
+    return Fcons (rep_MAKE_INT(VPART(part)->width),
+		  rep_MAKE_INT(VPART(part)->height));
+}
+
+DEFUN("frame-part-state", Fframe_part_state,
+      Sframe_part_state, (repv part), rep_Subr1)
+{ 
+    rep_DECLARE1(part, PARTP);
+    return state_syms[current_state (VPART(part))];
+}
+
+DEFUN("map-frame-parts", Fmap_frame_parts,
+      Smap_frame_parts, (repv fun, repv win), rep_Subr2)
+{
+    rep_GC_root gc_win;
+    struct frame_part *fp;
+
+    rep_DECLARE (1, fun, Ffunctionp (fun) != Qnil);
+    rep_DECLARE2 (win, WINDOWP);
+
+    rep_PUSHGC (gc_win, win);
+    fp = VWIN(win)->frame_parts;
+    while (fp != 0)
+    {
+	repv tem = rep_call_lisp1 (fun, rep_VAL(fp));	/* fun,fp protected */
+	if (tem == rep_NULL)
+	    break;
+	fp = fp->next;
+    }
+    rep_POPGC;
+    return Qnil;
+}
+
+DEFUN("refresh-frame-part", Frefresh_frame_part,
+      Srefresh_frame_part, (repv part), rep_Subr1)
+{
+    rep_DECLARE1(part, PARTP);
+    if (VPART(part)->id != 0)
+	refresh_frame_part (VPART(part));
+    return Qt;
+}
+
+DEFUN("rebuild-frame-part", Frebuild_frame_part,
+      Srebuild_frame_part, (repv part), rep_Subr1)
+{
+    rep_GC_root gc_part;
+    rep_DECLARE1(part, PARTP);
+    rep_PUSHGC(gc_part, part);
+    if (build_frame_part (VPART(part)))
+    {
+	/* XXX what about reconfiguring the container window..? */
+	configure_frame_part (VPART(part));
+	queue_reshape_frame (VPART(part)->win);
+    }
+    rep_POPGC;
+    return Qt;
+}
+
+DEFUN("refresh-window", Frefresh_window,
+      Srefresh_window, (repv win), rep_Subr1)
+{
+    rep_DECLARE1(win, XWINDOWP);
+    if (!WINDOW_IS_GONE_P (VWIN(win)))
+	refresh_frame_parts (VWIN(win));
+    return Qt;
+}
+
+
+/* initialisation */
+
+void
+frames_init (void)
+{
+    repv tem;
+    frame_part_type = rep_register_new_type ("frame-part", fp_cmp, fp_prin,
+					     fp_prin, fp_sweep, fp_mark, 0,
+					     0, 0, 0, 0, 0, 0);
+
+    tem = rep_push_structure ("sawfish.wm.frames.subrs");
+    rep_ADD_SUBR(Sframe_draw_mutex);
+    rep_ADD_SUBR(Sframe_state_mutex);
+    rep_ADD_SUBR(Sframe_part_get);
+    rep_ADD_SUBR(Sframe_part_put);
+    rep_ADD_SUBR(Sframe_part_window);
+    rep_ADD_SUBR(Sframe_part_x_window);
+    rep_ADD_SUBR(Sframe_part_position);
+    rep_ADD_SUBR(Sframe_part_dimensions);
+    rep_ADD_SUBR(Sframe_part_state);
+    rep_ADD_SUBR(Smap_frame_parts);
+    rep_ADD_SUBR(Srefresh_frame_part);
+    rep_ADD_SUBR(Srebuild_frame_part);
+    rep_pop_structure (tem);
+
+    tem = rep_push_structure ("sawfish.wm.windows.subrs");
+    rep_ADD_SUBR(Srefresh_window);
+    rep_pop_structure (tem);
+
+    rep_INTERN(internal);
+    rep_INTERN(tiled);
+    rep_INTERN(center);
+    rep_INTERN(right);
+    rep_INTERN(left);
+    rep_INTERN(top);
+    rep_INTERN(bottom);
+    rep_INTERN(text);
+    rep_INTERN(x_justify);
+    rep_INTERN(y_justify);
+    rep_INTERN(background);
+    rep_INTERN(foreground);
+    rep_INTERN(renderer);
+    rep_INTERN(render_scale);
+    rep_INTERN(font);
+    rep_INTERN(width);
+    rep_INTERN(height);
+    rep_INTERN(left_edge);
+    rep_INTERN(top_edge);
+    rep_INTERN(right_edge);
+    rep_INTERN(bottom_edge);
+    rep_INTERN(cursor);
+    rep_INTERN(focused);
+    rep_INTERN(highlighted);
+    rep_INTERN(clicked);
+    rep_INTERN(inactive);
+    rep_INTERN(inactive_highlighted);
+    rep_INTERN(inactive_clicked);
+    rep_INTERN(hide_client);
+    rep_INTERN(class);
+    rep_INTERN(removable);
+    rep_INTERN(removed_classes);
+    rep_INTERN(below_client);
+    rep_INTERN(scale_foreground);
+    rep_INTERN(hidden);
+
+    rep_INTERN_SPECIAL(frame_part_classes);
+    rep_INTERN_SPECIAL(override_frame_part_classes);
+
+    state_syms[fps_inactive] = Qnil;
+    state_syms[fps_focused] = Qfocused;
+    state_syms[fps_highlighted] = Qhighlighted;
+    state_syms[fps_clicked] = Qclicked;
+    state_syms[fps_inactive_highlighted] = Qinactive_highlighted;
+    state_syms[fps_inactive_clicked] = Qinactive_clicked;
+
+    if (!batch_mode_p ())
+	window_fp_context = XUniqueContext ();
+}
+
+void
+frames_kill (void)
+{
+}

--- /dev/null
+++ b/src/functions.c
@@ -0,0 +1,1450 @@
+/* functions.c -- useful window manager Lisp functions
+   $Id$
+
+   Copyright (C) 1999 John Harper <[e-mail]>
+
+   This file is part of sawmill.
+
+   sawmill 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, or (at your option)
+   any later version.
+
+   sawmill 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 sawmill; see the file COPYING.   If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* Define this to fake two side-by-side Xinerama style heads */
+#undef TEST_XINERAMA
+
+/* AIX requires this to be the first thing in the file.  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+ #pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+   char *alloca ();
+#   endif
+#  endif
+# endif
+#endif
+   
+#include "sawmill.h"
+#include <X11/Xatom.h>
+
+/* Number of outstanding server grabs made; only when this is zero is
+   the server ungrabbed. */
+static int server_grabs;
+
+static int xinerama_heads;
+
+#ifdef HAVE_X11_EXTENSIONS_XINERAMA_H
+# include <X11/extensions/Xinerama.h>
+  static XineramaScreenInfo *xinerama_head_info;
+# ifdef TEST_XINERAMA
+   static XineramaScreenInfo debug_heads[2] = {
+     { 0, 0, 0, 512, 768 },
+     { 0, 512, 0, 512, 768 }
+   };
+   static int debug_nheads = 2;
+# else
+   static int xinerama_event_base, xinerama_error_base;
+# endif
+#endif
+
+DEFSYM(root, "root");
+DEFSYM(after_restacking_hook, "after-restacking-hook");
+DEFSYM(position, "position");
+DEFSYM(spacing, "spacing");
+DEFSYM(window, "window");
+DEFSYM(head, "head");
+
+DEFUN("restack-windows", Frestack_windows, Srestack_windows,
+      (repv list), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#restack-windows::
+restack-windows LIST
+
+Restack all windows in the list of windows LIST in the order they occur
+in the list (from top to bottom). The stacking order of any unspecified
+windows isn't affected.
+::end:: */
+{
+    repv ptr;
+    Lisp_Window *pred;
+
+    rep_DECLARE1(list, rep_LISTP);
+    for (ptr = list; rep_CONSP (ptr); ptr = rep_CDR (ptr))
+    {
+	if (!WINDOWP (rep_CAR (ptr)))
+	    return rep_signal_arg_error (list, 1);
+    }
+
+    if (list == Qnil)
+	return Qt;
+
+    ptr = list;
+    pred = 0;
+
+    while (rep_CONSP (ptr))
+    {
+	Lisp_Window *this = VWIN (rep_CAR (ptr));
+
+	if (!WINDOW_IS_GONE_P (this))
+	{
+	    if (pred != 0 && !WINDOW_IS_GONE_P (pred))
+	    {
+		remove_from_stacking_list (this);
+		insert_in_stacking_list_below (this, pred);
+
+		/* This works because it tries to stack relative to
+		   the window above THIS first; which we just set */
+		restack_window (this);
+	    }
+	    pred = this;
+	}
+
+	ptr = rep_CDR (ptr);
+
+	rep_TEST_INT;
+	if (rep_INTERRUPTP)
+	    return rep_NULL;
+    }
+
+    Fcall_hook (Qafter_restacking_hook, Qnil, Qnil);
+    return Qt;
+}
+
+DEFUN("x-raise-window", Fx_raise_window, Sx_raise_window,
+      (repv win, repv above), rep_Subr2) /*
+::doc:sawfish.wm.windows.subrs#x-raise-window::
+x-raise-window WINDOW [ABOVE]
+
+Raise WINDOW so that it is above window ABOVE. If ABOVE is undefined,
+raise WINDOW to the top of the stacking order.
+::end:: */
+{
+    rep_DECLARE1 (win, WINDOWP);
+
+    if (!WINDOW_IS_GONE_P (VWIN (win)))
+    {
+	if (WINDOWP (above))
+	{
+	    if (!WINDOW_IS_GONE_P (VWIN (above)))
+	    {
+		remove_from_stacking_list (VWIN (win));
+		insert_in_stacking_list_above (VWIN (win), VWIN (above));
+	    }
+	}
+	else
+	{
+	    remove_from_stacking_list (VWIN (win));
+	    insert_in_stacking_list_above_all (VWIN (win));
+	}
+	restack_window (VWIN (win));
+	Fcall_hook (Qafter_restacking_hook, Qnil, Qnil);
+    }
+    return win;
+}
+
+DEFUN("x-lower-window", Fx_lower_window, Sx_lower_window,
+      (repv win, repv below), rep_Subr2) /*
+::doc:sawfish.wm.windows.subrs#x-lower-window::
+x-lower-window WINDOW [BELOW]
+
+Lower WINDOW so that it is below window BELOW. If BELOW is undefined,
+lower WINDOW to the bottom of the stacking order.
+::end:: */
+{
+    rep_DECLARE1 (win, WINDOWP);
+
+    if (!WINDOW_IS_GONE_P (VWIN (win)))
+    {
+	if (WINDOWP (below))
+	{
+	    if (!WINDOW_IS_GONE_P (VWIN (below)))
+	    {
+		remove_from_stacking_list (VWIN (win));
+		insert_in_stacking_list_below (VWIN (win), VWIN (below));
+	    }
+	}
+	else
+	{
+	    remove_from_stacking_list (VWIN (win));
+	    insert_in_stacking_list_below_all (VWIN (win));
+	}
+	restack_window (VWIN (win));
+	Fcall_hook (Qafter_restacking_hook, Qnil, Qnil);
+    }
+    return win;
+}
+
+DEFUN("x-kill-client", Fx_kill_client, Sx_kill_client,
+      (repv win), rep_Subr1)
+{
+    Window w = x_win_from_arg (win);
+    if (w == 0)
+	return WINDOWP(win) ? Qnil : rep_signal_arg_error (win, 1);
+    XKillClient (dpy, w);
+    return win;
+}
+
+DEFUN_INT("destroy-window", Fdestroy_window, Sdestroy_window, (repv win), rep_Subr1, "%W") /*
+::doc:sawfish.wm.windows.subrs#destroy-window::
+destroy-window WINDOW
+
+Destroy WINDOW with out giving the owning application any warning.
+
+WINDOW may be a window object or a numeric window id.
+::end:: */
+{
+    if (WINDOWP(win))
+	XDestroyWindow (dpy, VWIN(win)->id);
+    else if (rep_INTEGERP(win))
+	XDestroyWindow (dpy, rep_get_long_uint (win));
+    else
+	return rep_signal_arg_error (win, 1);
+    return win;
+}
+
+DEFUN("warp-cursor", Fwarp_cursor, Swarp_cursor, (repv x, repv y), rep_Subr2) /*
+::doc:sawfish.wm.misc#warp-cursor::
+warp-cursor X Y
+
+Move the mouse pointer to position (X, Y) relative to the origin of the
+root window.
+::end:: */
+{
+    rep_DECLARE1(x, rep_INTP);
+    rep_DECLARE2(y, rep_INTP);
+    if (rep_INT(x) >= 0 && rep_INT(x) < screen_width
+	&& rep_INT(y) >= 0 && rep_INT(y) < screen_height)
+    {
+	XWarpPointer (dpy, None, root_window,
+		      0, 0, 0, 0, rep_INT(x), rep_INT(y));
+	invalidate_cached_mouse_position ();
+	return Qt;
+    }
+    else
+	return Qnil;
+}
+
+DEFUN("move-window-to", Fmove_window_to, Smove_window_to,
+      (repv win, repv x, repv y), rep_Subr3) /*
+::doc:sawfish.wm.windows.subrs#move-window-to::
+move-window-to WINDOW X Y
+
+Move the top-left corner of window object WINDOW to (X, Y).
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    rep_DECLARE2(x, rep_INTP);
+    rep_DECLARE3(y, rep_INTP);
+    if (VWIN(win)->attr.x != rep_INT(x) || VWIN(win)->attr.y != rep_INT(y))
+    {
+	VWIN(win)->attr.x = rep_INT(x);
+	VWIN(win)->attr.y = rep_INT(y);
+	XMoveWindow (dpy,
+		     VWIN(win)->reparented ? VWIN(win)->frame : VWIN(win)->id,
+		     VWIN(win)->attr.x, VWIN(win)->attr.y);
+	send_synthetic_configure (VWIN(win));
+	Fcall_window_hook (Qwindow_moved_hook, win, Qnil, Qnil);
+    }
+    return win;
+}
+
+DEFUN("resize-window-to", Fresize_window_to, Sresize_window_to,
+      (repv win, repv width, repv height), rep_Subr3) /*
+::doc:sawfish.wm.windows.subrs#resize-window-to::
+resize-window-to WINDOW WIDTH HEIGHT
+
+Set the dimensions of window object WINDOW to (WIDTH, HEIGHT).
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    rep_DECLARE2(width, rep_INTP);
+    rep_DECLARE3(height, rep_INTP);
+    VWIN(win)->attr.width = rep_INT(width);
+    VWIN(win)->attr.height = rep_INT(height);
+    fix_window_size (VWIN(win));
+    VWIN (win)->pending_configure = 0;
+    Fcall_window_hook (Qwindow_resized_hook, win, Qnil, Qnil);
+    return win;
+}
+
+DEFUN("move-resize-window-to", Fmove_resize_window_to, Smove_resize_window_to,
+      (repv win, repv x, repv y, repv width, repv height), rep_Subr5) /*
+::doc:sawfish.wm.windows.subrs#move-resize-window-to::
+move-resize-window-to WINDOW X Y WIDTH HEIGHT
+
+Reconfigure the geometry of window object WINDOW as specified.
+::end:: */
+{
+    bool resized, moved;
+    rep_DECLARE1(win, WINDOWP);
+    rep_DECLARE2(x, rep_INTP);
+    rep_DECLARE3(y, rep_INTP);
+    rep_DECLARE4(width, rep_INTP);
+    rep_DECLARE5(height, rep_INTP);
+    moved = (VWIN(win)->attr.x != rep_INT(x)
+	     || VWIN(win)->attr.y != rep_INT(y));
+    resized = (VWIN(win)->attr.width != rep_INT(width)
+	       || VWIN(win)->attr.height != rep_INT(height));
+    VWIN(win)->attr.x = rep_INT(x);
+    VWIN(win)->attr.y = rep_INT(y);
+    VWIN(win)->attr.width = rep_INT(width);
+    VWIN(win)->attr.height = rep_INT(height);
+    if (resized)
+    {
+	fix_window_size (VWIN(win));
+	VWIN (win)->pending_configure = 0;
+    }
+    if (moved && !resized)
+    {
+	XMoveWindow (dpy, VWIN(win)->reparented ? VWIN(win)->frame
+		     : VWIN(win)->id, VWIN(win)->attr.x, VWIN(win)->attr.y);
+	send_synthetic_configure (VWIN(win));
+    }
+    if (moved)
+	Fcall_window_hook (Qwindow_moved_hook, win, Qnil, Qnil);
+    if (resized)
+	Fcall_window_hook (Qwindow_resized_hook, win, Qnil, Qnil);
+    return win;
+}
+
+DEFUN("grab-server", Fgrab_server, Sgrab_server, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#grab-server::
+grab-server
+
+Prevent any other clients from accessing the X server. See `ungrab-server'.
+::end:: */
+{
+    if (server_grabs++ == 0)
+    {
+	XGrabServer (dpy);
+	XSync (dpy, False);
+	rep_mark_input_pending (ConnectionNumber (dpy));
+    }
+    return Qt;
+}
+
+DEFUN("ungrab-server", Fungrab_server, Sungrab_server, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#ungrab-server::
+ungrab-server
+
+After a call to `grab-server' this will allow other clients to access
+the X server again.
+
+Note that calls to `grab-server' and `ungrab-server' _nest_.
+::end:: */
+{
+    if (--server_grabs == 0)
+    {
+	XUngrabServer (dpy);
+	XFlush (dpy);
+    }
+    return Qt;
+}
+
+DEFUN("server-grabbed-p", Fserver_grabbed_p,
+      Sserver_grabbed_p, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#server-grabbed-p::
+server-grabbed-p
+
+Return t if the server is currently grabbed.
+::end:: */
+{
+    return (server_grabs > 0) ? Qt : Qnil;
+}
+
+/* Call this when the server may have been ungrabbed prematurely (imlib
+   lossage) */
+void
+regrab_server (void)
+{
+    if (server_grabs > 0)
+    {
+	server_grabs--;
+	Fgrab_server ();
+    }
+}
+
+DEFUN("grab-pointer", Fgrab_pointer, Sgrab_pointer,
+      (repv win, repv cursor, repv ptr_sync, repv kbd_sync, repv confine_to),
+      rep_Subr5) /*
+::doc:sawfish.wm.events#grab-pointer::
+grab-pointer [WINDOW] [CURSOR] [PTR-SYNC] [KBD-SYNC] [CONFINE-TO]
+
+Grab the pointer and direct all pointer events to window object
+WINDOW. If CURSOR is defined and a cursor object, display this whilst
+the pointer is grabbed.
+
+If PTR-SYNC or KBD-SYNC is non-nil the pointer or the keyboard will be
+frozen, i.e., the device will not produce events until either the grab
+is released or events are re-enabled using allow-events.
+
+CONFINE-TO, if non-nil, is a visible window to confine the pointer to.
+
+If WINDOW is a window object corresponding to a visible window the
+grab will be made on its frame.  If WINDOW is an integer, it specifies the
+window id of the grab window.  Otherwise the grab will be made on the root
+window.  CONFINE-TO is interpreted similarly except that the default
+is not to confine the pointer.  If the window id of a non-viewable window
+was specified for either WINDOW of CONFINE-TO the grab will be made on the
+root window without confining the pointer.
+
+Returns non-nil if the grab succeeded.
+::end:: */
+{
+    Window g_win, c_win;
+    int ret;
+
+    if (WINDOWP(win) && VWIN(win)->visible)
+	g_win = VWIN(win)->frame;
+    else if (rep_INTP(win))
+	g_win = rep_INT(win);
+    else
+	g_win = root_window;
+
+    if (WINDOWP(confine_to) && VWIN(confine_to)->visible)
+        c_win = VWIN(confine_to)->frame;
+    else if (rep_INTP(confine_to))
+	c_win = rep_INT(confine_to);
+    else
+        c_win = None;
+
+    if (cursor != Qnil && !CURSORP(cursor))
+    {
+	cursor = Fget_cursor (cursor);
+	if (!cursor)
+	    cursor = Qnil;
+    }
+
+again:
+    ret = XGrabPointer (dpy, g_win, False, POINTER_GRAB_EVENTS,
+			rep_NILP( ptr_sync) ? GrabModeAsync : GrabModeSync,
+			rep_NILP( kbd_sync) ? GrabModeAsync : GrabModeSync,
+			c_win,
+			CURSORP(cursor) ? VCURSOR(cursor)->cursor : None,
+			last_event_time);
+    if (ret == GrabNotViewable && (g_win != root_window || c_win != None))
+    {
+	/* fall back to the root window. */
+	g_win = root_window;
+	c_win = None;
+	goto again;
+    }
+
+    DB(("grab-pointer: time=%lu ret=%d\n", last_event_time, ret));
+    return (ret == GrabSuccess) ? Qt : Qnil;
+}
+
+DEFUN("ungrab-pointer", Fungrab_pointer, Sungrab_pointer, (void), rep_Subr0) /*
+::doc:sawfish.wm.events#ungrab-pointer::
+ungrab-pointer
+
+Release the grab on the mouse pointer.
+::end:: */
+{
+    XUngrabPointer (dpy, last_event_time);
+    synthesize_button_release ();
+    DB(("ungrab-pointer: time=%lu\n", last_event_time));
+    return Qt;
+}
+
+DEFUN("grab-keyboard", Fgrab_keyboard, Sgrab_keyboard,
+      (repv win, repv ptr_sync, repv kbd_sync), rep_Subr3) /*
+::doc:sawfish.wm.events#grab-keyboard::
+grab-keyboard [WINDOW] [PTR-SYNC] [KBD-SYNC]
+
+Grab the keyboard and direct all keyboard events to window object
+WINDOW.  If WINDOW is a window object corresponding to a visible
+window the grab will be made on its frame.  If WINDOW is an integer it
+specifies the window id of the grab window.  Otherwise the grab will
+be made on the root window.  If the window id of a non-viewable window
+was specified the grab is made on the root window instead.
+
+If PTR-SYNC or KBD-SYNC is non-nil the pointer or the keyboard will be
+frozen, i.e., the device will not produce events until either the grab
+is released or events are re-enabled using allow-events.
+
+Returns non-nil if the grab succeeded.
+::end:: */
+{
+    Window g_win;
+    int ret;
+
+    if (WINDOWP(win) && VWIN(win)->visible)
+	g_win = VWIN(win)->frame;
+    else if (rep_INTP(win))
+	g_win = rep_INT(win);
+    else
+	g_win = root_window;
+
+again:
+    ret = XGrabKeyboard (dpy, g_win, False,
+			 rep_NILP( ptr_sync) ? GrabModeAsync : GrabModeSync,
+			 rep_NILP( kbd_sync) ? GrabModeAsync : GrabModeSync,
+			 last_event_time);
+    if (ret == GrabNotViewable && g_win != root_window)
+    {
+	/* fall back to the root window. */
+	g_win = root_window;
+	goto again;
+    }
+
+    DB(("grab-keyboard: time=%lu ret=%d\n", last_event_time, ret));
+    return (ret == GrabSuccess) ? Qt : Qnil;
+}
+    
+DEFUN("ungrab-keyboard", Fungrab_keyboard,
+      Sungrab_keyboard, (void), rep_Subr0) /*
+::doc:sawfish.wm.events#ungrab-keyboard::
+ungrab-keyboard
+
+Release the grab on the keyboard.
+::end:: */
+{
+    DB(("ungrab-keyboard: time=%lu\n", last_event_time));
+    XUngrabKeyboard (dpy, last_event_time);
+    return Qt;
+}
+
+DEFUN("screen-width", Fscreen_width, Sscreen_width, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#screen-width::
+screen-width
+
+Return the width of the root window (in pixels).
+::end:: */
+{
+    return rep_MAKE_INT(screen_width);
+}
+
+DEFUN("screen-height", Fscreen_height, Sscreen_height, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#screen-height::
+screen-height
+
+Return the height of the root window (in pixels).
+::end:: */
+{
+    return rep_MAKE_INT(screen_height);
+}
+
+DEFUN("sync-server", Fsync_server, Ssync_server, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#sync-server::
+sync-server
+
+Flush all pending X requests, don't wait for them to finish.
+::end:: */
+{
+    XFlush (dpy);
+    return Qt;
+}
+
+DEFUN("delete-x-property", Fdelete_x_property, Sdelete_x_property,
+      (repv win, repv atom), rep_Subr2) /*
+::doc:sawfish.wm.misc#delete-x-property::
+delete-x-property WINDOW ATOM
+
+Delete the X property ATOM (a symbol) of WINDOW.
+
+WINDOW may be the symbol `root', a window object or a numeric window id.
+::end:: */
+{
+    Window w = x_win_from_arg (win);
+    rep_DECLARE2(atom, rep_SYMBOLP);
+    if (w == 0)
+	return WINDOWP(win) ? atom : rep_signal_arg_error (win, 1);
+    XDeleteProperty (dpy, w,
+		     XInternAtom (dpy, rep_STR(rep_SYM(atom)->name), False));
+    return atom;
+}
+
+DEFUN("list-x-properties", Flist_x_properties, Slist_x_properties,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.misc#list-x-properties::
+list-x-properties WINDOW
+
+List all X properties (symbols) of WINDOW.
+
+WINDOW may be the symbol `root', a window object or a numeric window id.
+::end:: */
+{
+    Window w;
+    Atom *atoms;
+    int count;
+    repv ret = Qnil;
+
+    w = x_win_from_arg (win);
+    if (w == 0)
+	return WINDOWP(win) ? Qnil : rep_signal_arg_error (win, 1);
+    atoms = XListProperties (dpy, w, &count);
+    if (atoms != 0)
+    {
+	char **names = alloca (sizeof (char *) * count);
+	if (XGetAtomNames (dpy, atoms, count, names) != 0)
+	{
+	    int i;
+	    for (i = 0; i < count; i++)
+	    {
+		ret = Fcons (Fintern (rep_string_dup (names[i]),
+				      rep_obarray), ret);
+		XFree (names[i]);
+	    }
+	}
+	XFree (atoms);
+    }
+    return Fnreverse (ret);
+}
+
+DEFUN("get-x-property", Fget_x_property, Sget_x_property,
+      (repv win, repv prop), rep_Subr2) /*
+::doc:sawfish.wm.misc#get-x-property::
+get-x-property WINDOW PROPERTY
+
+Return (TYPE FORMAT DATA) representing the X property PROPERTY (a
+symbol) of WINDOW. If no such property exists, return nil.
+
+WINDOW may be the symbol `root', a window object or a numeric window
+id.
+
+TYPE is a symbol representing the atom defining the type of the
+property. FORMAT is an integer, either 8, 16 or 32, defining the width
+of the data items read. DATA is an array, either a string for an 8-bit
+format, or a vector of integers.
+
+If TYPE is `ATOM' and FORMAT is 32, then DATA will be a vector of
+symbols, representing the atoms read.
+::end:: */
+{
+    Window w;
+    Atom a_prop;
+    Atom type;
+    int format;
+    u_long nitems;
+    u_char *data = 0;
+    repv type_sym, ret_data = Qnil;
+
+    w = x_win_from_arg (win);
+    rep_DECLARE2(prop, rep_SYMBOLP);
+    if (w == 0)
+	return WINDOWP(win) ? Qnil : rep_signal_arg_error (win, 1);
+    a_prop = XInternAtom (dpy, rep_STR(rep_SYM(prop)->name), False);
+
+    /* First read the data.. */
+    {
+	long long_length = 32;
+	u_long bytes_after;
+	while (1)
+	{
+	    if (data != 0)
+		XFree (data);
+	    if (XGetWindowProperty (dpy, w, a_prop, 0, long_length, False,
+				    AnyPropertyType, &type, &format,
+				    &nitems, &bytes_after, &data) != Success)
+		return Qnil;
+	    if (type == None)
+		return Qnil;
+	    if (bytes_after == 0)
+		break;
+	    long_length += (bytes_after / sizeof(u_long)) + 1;
+	}
+    }
+
+    /* Convert the type to a symbol */
+    type_sym = x_atom_symbol (type);
+    
+    /* Then convert the contents to a vector or string */
+    switch (format)
+    {
+	u_short *s_data;
+	u_long *l_data;
+	int i;
+
+    case 8:
+	ret_data = rep_string_dupn (data, nitems);
+	break;
+
+    case 16:
+	ret_data = Fmake_vector (rep_MAKE_INT(nitems), Qnil);
+	s_data = (u_short *)data;
+	for (i = 0; i < nitems; i++)
+	    rep_VECTI(ret_data, i) = rep_MAKE_INT(s_data[i]);
+	break;
+
+    case 32:
+	ret_data = Fmake_vector (rep_MAKE_INT(nitems), Qnil);
+	l_data = (u_long *)data;
+	for (i = 0; i < nitems; i++)
+	{
+	    repv name;
+	    if (type == XA_ATOM && (name = x_atom_symbol (l_data[i])) != Qnil)
+		rep_VECTI(ret_data, i) = name;
+	    else
+		rep_VECTI(ret_data, i) = rep_make_long_uint(l_data[i]);
+	}
+	break;
+    }
+    XFree (data);
+
+    return rep_list_3 (type_sym, rep_MAKE_INT(format), ret_data);
+}
+
+DEFUN("set-x-property", Fset_x_property, Sset_x_property,
+      (repv win, repv prop, repv data, repv type, repv format), rep_Subr5) /*
+::doc:sawfish.wm.misc#set-x-property::
+set-x-property WINDOW PROPERTY DATA TYPE FORMAT
+
+Set the X property PROPERTY (a symbol) of WINDOW to the array DATA.
+
+WINDOW may be the symbol `root', a window object or a numeric window
+id.
+
+TYPE is a symbol representing the atom defining the type of the
+property, FORMAT is either 8, 16 or 32 defining the width of the data
+values. DATA is either a string or a vector of integers.
+
+If TYPE is `ATOM' and FORMAT is 32, then any symbols in DATA will be
+converted to their numeric X atoms.
+::end:: */
+{
+    Window w;
+    Atom a_prop, a_type;
+    u_long nitems;
+    u_char *c_data = 0;
+
+    w = x_win_from_arg (win);
+    rep_DECLARE2(prop, rep_SYMBOLP);
+    a_prop = XInternAtom (dpy, rep_STR(rep_SYM(prop)->name), False);
+    rep_DECLARE(3, data, rep_VECTORP(data) || rep_STRINGP(data));
+    rep_DECLARE4(type, rep_SYMBOLP);
+    a_type = XInternAtom (dpy, rep_STR(rep_SYM(type)->name), False);
+    rep_DECLARE5(format, rep_INTP);
+    if (w == 0)
+	return WINDOWP(win) ? prop : rep_signal_arg_error (win, 1);
+
+    /* Convert to data array */
+
+    if (rep_STRINGP(data))
+	nitems = rep_STRING_LEN(data);
+    else
+	nitems = rep_VECT_LEN(data);
+
+    switch (rep_INT(format))
+    {
+	int i;
+	u_short *s_data;
+	u_long *l_data;
+
+    case 8:
+	if (rep_STRINGP(data))
+	    c_data = rep_STR (data);
+	else
+	{
+	    c_data = alloca (nitems);
+	    for (i = 0; i < nitems; i++)
+		c_data[i] = rep_STR(data)[i];
+	}
+	break;
+
+    case 16:
+	if (rep_STRINGP(data))
+	    return rep_signal_arg_error (data, 3);
+	c_data = alloca (nitems * sizeof (u_short));
+	s_data = (u_short *)c_data;
+	for (i = 0; i < nitems; i++)
+	    s_data[i] = rep_INT(rep_VECTI(data, i));
+	break;
+
+    case 32:
+	if (rep_STRINGP(data))
+	    return rep_signal_arg_error (data, 3);
+	c_data = alloca (nitems * sizeof (u_long));
+	l_data = (u_long *)c_data;
+	for (i = 0; i < nitems; i++)
+	{
+	    if (a_type == XA_ATOM && rep_SYMBOLP(rep_VECTI(data, i)))
+		l_data[i] = XInternAtom (dpy, rep_STR(rep_SYM(rep_VECTI(data, i))->name), False);
+	    else
+		l_data[i] = rep_get_long_uint (rep_VECTI(data, i));
+	}
+	break;
+    }
+
+    /* Overwrite property */
+    XChangeProperty (dpy, w, a_prop, a_type, rep_INT(format),
+		     PropModeReplace, c_data, nitems);
+    return prop;
+}
+
+DEFUN("get-x-text-property", Fget_x_text_property, Sget_x_text_property,
+      (repv win, repv prop), rep_Subr2) /*
+::doc:sawfish.wm.misc#get-x-text-property::
+get-x-text-property WINDOW PROPERTY
+::end:: */
+{
+    Window w;
+    Atom a_prop;
+    XTextProperty t_prop;
+    repv ret = Qnil;
+
+    w = x_win_from_arg (win);
+    rep_DECLARE2(prop, rep_SYMBOLP);
+    if (w == 0)
+	return WINDOWP(win) ? Qnil : rep_signal_arg_error (win, 1);
+    a_prop = XInternAtom (dpy, rep_STR(rep_SYM(prop)->name), False);
+
+    if (XGetTextProperty (dpy, w, &t_prop, a_prop) != 0)
+    {
+	char **list;
+	int count;
+	if (XTextPropertyToStringList (&t_prop, &list, &count) != 0)
+	{
+	    int i;
+	    ret = Fmake_vector (rep_MAKE_INT(count), Qnil);
+	    for (i = 0; i < count; i++)
+		rep_VECTI(ret, i) = rep_string_dup (list[i]);
+	    XFreeStringList (list);
+	}
+	XFree (t_prop.value);
+    }
+
+    return ret;
+}
+
+DEFUN("set-x-text-property", Fset_x_text_property, Sset_x_text_property, 
+      (repv win, repv prop, repv vect), rep_Subr3) /*
+::doc:sawfish.wm.misc#set-x-text-prooperty::
+set-x-text-property WINDOW PROPERTY STRING-VECTOR
+::end:: */
+{
+    Window w;
+    Atom a_prop;
+    XTextProperty t_prop;
+    char **strings;
+    int count, i;
+
+    w = x_win_from_arg (win);
+    rep_DECLARE2(prop, rep_SYMBOLP);
+    rep_DECLARE3(vect, rep_VECTORP);
+    if (w == 0)
+	return WINDOWP(win) ? Qnil : rep_signal_arg_error (win, 1);
+    a_prop = XInternAtom (dpy, rep_STR(rep_SYM(prop)->name), False);
+
+    count = rep_VECT_LEN(vect);
+    strings = alloca (sizeof (char *) * (count + 1));
+    for (i = 0; i < count; i++)
+    {
+	if (!rep_STRINGP(rep_VECTI(vect, i)))
+	    return rep_signal_arg_error (vect, 3);
+	strings[i] = rep_STR(rep_VECTI(vect, i));
+    }
+    if (XStringListToTextProperty (strings, count, &t_prop) != 0)
+    {
+	XSetTextProperty (dpy, w, &t_prop, a_prop);
+	XFree (t_prop.value);
+    }
+
+    return Qt;
+}
+
+DEFUN("send-client-message", Fsend_client_message, Ssend_client_message,
+      (repv win, repv type, repv data, repv format), rep_Subr4) /*
+::doc:sawfish.wm.events#send-client-message::
+send-client-message WINDOW TYPE DATA FORMAT
+
+Send an X ClientMessage event to WINDOW (a window object or the symbol
+`root'). It will be of the type TYPE (a symbol), contain the array of
+integers DATA (i.e. a vector or a string), and it will be transferred as
+FORMAT sized quantities (8, 16 or 32).
+::end:: */
+{
+    XClientMessageEvent ev;
+    Window w = x_win_from_arg (win);
+
+    rep_DECLARE2(type, rep_SYMBOLP);
+    rep_DECLARE(3, data, rep_STRINGP(data) || rep_VECTORP(data));
+    rep_DECLARE4(format, rep_INTP);
+
+    if (w == 0)
+	return WINDOWP(win) ? Qnil : rep_signal_arg_error (win, 1);
+
+    ev.type = ClientMessage;
+    ev.window = w;
+    ev.message_type = XInternAtom (dpy, rep_STR(rep_SYM(type)->name), False);
+    ev.format = rep_INT(format);
+
+    switch (rep_INT(format))
+    {
+	int i;
+
+    case 8:
+	if (rep_STRINGP(data))
+	    memcpy (rep_STR(data), ev.data.b, MAX(rep_STRING_LEN(data), 20));
+	else
+	{
+	    for (i = 0; i < rep_VECT_LEN(data) && i < 20; i++)
+		ev.data.b[i] = rep_INT(rep_VECTI(data, i));
+	}
+	break;
+
+    case 16:
+	if (rep_STRINGP(data))
+	    return rep_signal_arg_error (data, 3);
+	for (i = 0; i < rep_VECT_LEN(data) && i < 10; i++)
+	    ev.data.s[i] = rep_INT(rep_VECTI(data, i));
+	break;
+
+    case 32:
+	if (rep_STRINGP(data))
+	    return rep_signal_arg_error (data, 3);
+	for (i = 0; i < rep_VECT_LEN(data) && i < 5; i++)
+	    ev.data.l[i] = rep_get_long_uint (rep_VECTI(data, i));
+	break;
+    }
+
+    XSendEvent (dpy, w, False, 0L, (XEvent *) &ev);
+    return win;
+}
+
+DEFUN("create-window", Fcreate_window, Screate_window,
+      (repv parent, repv x, repv y, repv width, repv height), rep_Subr5) /*
+::doc:sawfish.wm.misc#create-window::
+create-window PARENT-WINDOW X Y WIDTH HEIGHT
+
+Create an unmapped window that is a child of PARENT-WINDOW (a window object,
+an integer window id, or the symbol `root'), with the specified dimensions.
+
+Returns the window id of the new window.
+::end:: */
+{
+    Window parent_w = x_win_from_arg (parent);
+    Window id;
+    rep_DECLARE2(x, rep_INTP);
+    rep_DECLARE3(y, rep_INTP);
+    rep_DECLARE4(width, rep_INTP);
+    rep_DECLARE5(height, rep_INTP);
+    if (parent_w == 0)
+	return WINDOWP(parent) ? Qnil : rep_signal_arg_error (parent, 1);
+    id = XCreateSimpleWindow (dpy, parent_w, rep_INT(x), rep_INT(y),
+			      rep_INT(width), rep_INT(height),
+			      0, BlackPixel (dpy, screen_num),
+			      WhitePixel (dpy, screen_num));
+    return id ? rep_MAKE_INT(id) : Qnil;
+}
+
+DEFUN("x-atom", Fx_atom, Sx_atom, (repv symbol), rep_Subr1) /*
+::doc:sawfish.wm.misc#x-atom::
+x-atom SYMBOL
+
+Return the integer identifying the X atom with the same name as SYMBOL.
+::end:: */
+{
+    rep_DECLARE1(symbol, rep_SYMBOLP);
+    return rep_MAKE_INT (XInternAtom (dpy, rep_STR(rep_SYM(symbol)->name),
+				      False));
+}
+
+DEFUN("x-atom-name", Fx_atom_name, Sx_atom_name, (repv atom), rep_Subr1) /*
+::doc:sawfish.wm.misc#x-atom-name::
+x-atom-name ATOM
+
+Return the symbol with the same name as the X atom identified by the
+integer ATOM.
+::end:: */
+{
+    rep_DECLARE1(atom, rep_INTP);
+    return x_atom_symbol (rep_INT(atom));
+}
+
+DEFUN("root-window-id", Froot_window_id, Sroot_window_id, (void), rep_Subr0) /*
+::doc:sawfish.wm.misc#root-window-id::
+root-window-id
+
+Returns the numeric id of the root window of the managed screen.
+::end:: */
+{
+    return rep_MAKE_INT (root_window);
+}
+
+
+/* xinerama support */
+
+DEFUN ("head-count", Fhead_count, Shead_count, (void), rep_Subr0)
+{
+    return rep_MAKE_INT (MAX (1, xinerama_heads));
+}
+
+DEFUN ("find-head", Ffind_head, Sfind_head, (repv x, repv y), rep_Subr2)
+{
+    if (rep_CONSP (x) && y == Qnil)
+    {
+	y = rep_CDR (x);
+	x = rep_CAR (x);
+    }
+    rep_DECLARE (1, x, rep_INTP (x));
+    rep_DECLARE (2, y, rep_INTP (y));
+
+#ifdef HAVE_X11_EXTENSIONS_XINERAMA_H
+    {
+	int i;
+	for (i = 0; i < xinerama_heads; i++)
+	{
+	    if ((xinerama_head_info[i].x_org <= rep_INT (x))
+		&& (xinerama_head_info[i].y_org <= rep_INT (y))
+		&& (xinerama_head_info[i].x_org
+		    + xinerama_head_info[i].width > rep_INT (x))
+		&& (xinerama_head_info[i].y_org
+		    + xinerama_head_info[i].height > rep_INT (y)))
+	    {
+		return rep_MAKE_INT (i);
+	    }
+	}
+    }
+#endif
+    if (xinerama_heads == 0
+	&& rep_INT (x) >= 0 && rep_INT (x) < screen_width
+	&& rep_INT (y) >= 0 && rep_INT (y) < screen_height)
+    {
+	return rep_MAKE_INT (0);
+    }
+    return Qnil;
+}
+
+DEFUN ("head-dimensions", Fhead_dimensions,
+       Shead_dimensions, (repv id), rep_Subr1)
+{
+    rep_DECLARE (1, id, rep_INTP (id));
+
+    if (xinerama_heads == 0 && rep_INT (id) == 0)
+    {
+	return Fcons (rep_MAKE_INT (screen_width),
+		      rep_MAKE_INT (screen_height));
+    }
+    else
+    {
+	rep_DECLARE (1, id, rep_INT (id) >= 0
+		     && rep_INT (id) < xinerama_heads);
+#ifdef HAVE_X11_EXTENSIONS_XINERAMA_H
+	return Fcons (rep_MAKE_INT (xinerama_head_info[rep_INT(id)].width),
+		      rep_MAKE_INT (xinerama_head_info[rep_INT(id)].height));
+#else
+	abort ();
+#endif
+    }
+}
+
+DEFUN ("head-offset", Fhead_offset, Shead_offset, (repv id), rep_Subr1)
+{
+    rep_DECLARE (1, id, rep_INTP (id));
+
+    if (xinerama_heads == 0 && rep_INT (id) == 0)
+    {
+	return Fcons (rep_MAKE_INT (0), rep_MAKE_INT (0));
+    }
+    else
+    {
+	rep_DECLARE (1, id, rep_INT (id) >= 0
+		     && rep_INT (id) < xinerama_heads);
+#ifdef HAVE_X11_EXTENSIONS_XINERAMA_H
+	return Fcons (rep_MAKE_INT (xinerama_head_info[rep_INT(id)].x_org),
+		      rep_MAKE_INT (xinerama_head_info[rep_INT(id)].y_org));
+#else
+	abort ();
+#endif
+    }
+}
+
+
+/* Displaying a `message' window */
+
+static Window message_win;
+
+static struct {
+    GC gc;
+    repv text, fg, bg, font, justify;
+    int width, spacing;
+} message;
+
+#define MSG_PAD_X 20
+#define MSG_PAD_Y 10
+
+static void
+refresh_message_window ()
+{
+    if (message_win != 0)
+    {
+	XGCValues values;
+	u_long mask;
+	char *ptr;
+	int row = 0;
+
+	values.foreground = VCOLOR(message.fg)->pixel;
+	values.background = VCOLOR(message.bg)->pixel;
+	mask = GCForeground | GCBackground;
+
+	if (message.gc == 0)
+	    message.gc = XCreateGC (dpy, message_win, mask, &values);
+	else
+	    XChangeGC (dpy, message.gc, mask, &values);
+
+	XClearWindow (dpy, message_win);
+
+	ptr = rep_STR(message.text);
+	while (*ptr != 0)
+	{
+	    char *end = strchr (ptr, '\n');
+	    int offset;
+	    if (end == 0)
+		end = ptr + strlen (ptr);
+	    if (message.justify == Qleft)
+		offset = MSG_PAD_X;
+	    else
+	    {
+		int width = x_text_width (message.font, ptr, end - ptr);
+		if (message.justify == Qright)
+		    offset = message.width - (width + MSG_PAD_X);
+		else
+		    offset = (message.width - width) / 2;
+	    }
+	    x_draw_string (message_win, message.font,
+			   message.gc, offset,
+			   MSG_PAD_Y
+			   + row * (VFONT(message.font)->ascent
+				    + VFONT(message.font)->descent
+				    + message.spacing)
+			   + VFONT(message.font)->ascent, ptr, end - ptr);
+	    row++;
+	    ptr = end;
+	    if (*ptr == '\n')
+		ptr++;
+	}
+    }
+}
+
+static void
+message_event_handler (XEvent *ev)
+{
+	if (ev->type == Expose)
+	refresh_message_window ();
+    else if (ev->type == ButtonPress)
+	Fdisplay_message (Qnil, Qnil);
+}
+
+DEFSTRING(white, "white");
+DEFSTRING(black, "black");
+
+DEFUN("display-message", Fdisplay_message, Sdisplay_message,
+      (repv text, repv attrs), rep_Subr2)
+{
+    if (text == Qnil)
+    {
+	if (message_win != 0)
+	{
+	    deregister_event_handler (message_win);
+	    XDestroyWindow (dpy, message_win);
+	    message_win = 0;
+	}
+	if (message.gc != 0)
+	{
+	    XFreeGC (dpy, message.gc);
+	    message.gc = 0;
+	}
+	message.font = message.fg = message.bg = message.text = Qnil;
+	return Qnil;
+    }
+    else
+    {
+	int height, x, y;
+	repv tem;
+
+	rep_DECLARE1(text, rep_STRINGP);
+	rep_DECLARE2(attrs, rep_LISTP);
+
+	message.text = text;
+	message.font = message.fg = message.bg = Qnil;
+	message.justify = Qleft;
+	message.spacing = 0;
+
+	tem = Fassq (Qfont, attrs);
+	if (tem && rep_CONSP(tem))
+	{
+	    message.font = rep_CDR(tem);
+	    if (!FONTP(message.font))
+	    {
+		message.font = Fget_font (message.font);
+		if (!message.font)
+		    return rep_NULL;
+	    }
+	}
+	if (!FONTP(message.font))
+	    message.font = global_symbol_value (Qdefault_font);
+	if (!FONTP(message.font))
+	    return rep_signal_arg_error (Qfont, 1);
+
+	tem = Fassq (Qforeground, attrs);
+	if (tem && rep_CONSP(tem))
+	{
+	    message.fg = rep_CDR(tem);
+	    if (!COLORP(message.fg))
+	    {
+		message.fg = Fget_color (message.fg);
+		if (!message.fg)
+		    return rep_NULL;
+	    }
+	}
+	if (!COLORP(message.fg))
+	    message.fg = Fget_color (rep_VAL(&black));
+	if (!COLORP(message.fg))
+	    return rep_signal_arg_error (Qforeground, 1);
+
+	tem = Fassq (Qbackground, attrs);
+	if (tem && rep_CONSP(tem))
+	{
+	    message.bg = rep_CDR(tem);
+	    if (!COLORP(message.bg))
+	    {
+		message.bg = Fget_color (message.bg);
+		if (!message.bg)
+		    return rep_NULL;
+	    }
+	}
+	if (!COLORP(message.bg))
+	    message.bg = Fget_color (rep_VAL(&white));
+	if (!COLORP(message.bg))
+	    return rep_signal_arg_error (Qbackground, 1);
+
+	tem = Fassq (Qx_justify, attrs);
+	if (tem && rep_CONSP(tem))
+	    message.justify = rep_CDR(tem);
+
+	tem = Fassq (Qspacing, attrs);
+	if (tem && rep_CONSP(tem) && rep_INTP(rep_CDR(tem)))
+	    message.spacing = rep_INT(rep_CDR(tem));
+
+	{
+	    char *ptr = rep_STR(text);
+	    int max_width = 0, rows = 0;
+	    repv head = Qnil;
+	    int head_width, head_height;
+	    int head_xoff, head_yoff;
+	    while (*ptr != 0)
+	    {
+		int text_width;
+		char *end = strchr (ptr, '\n');
+		if (end == 0)
+		  end = ptr + strlen (ptr);
+		text_width = x_text_width (message.font, ptr, end - ptr);
+		max_width = MAX(max_width, text_width);
+		rows++;
+		ptr = end;
+		if (*ptr == '\n')
+		  ptr++;
+	    }
+	    message.width = max_width + MSG_PAD_X * 2;
+	    height = ((rep_INT(Ffont_height (message.font)) + message.spacing)
+		      * rows + MSG_PAD_Y * 2);
+
+	    /* Find the head to put the message on. */
+	    tem = Fassq (Qhead, attrs);
+	    if (tem && rep_CONSP (tem) && rep_INTP (rep_CDR (tem)))
+		head = rep_CDR (tem);
+	    if (!head || head == Qnil)
+		head = Ffind_head (Fquery_pointer (Qnil), Qnil);
+
+	    if (head && head != Qnil)
+	    {
+		/* We have a head to centre on. */
+
+		tem = Fhead_dimensions (head);
+		if (!tem)
+		    goto no_head;
+		head_width = rep_INT (rep_CAR (tem));
+		head_height = rep_INT (rep_CDR (tem));
+
+		tem = Fhead_offset (head);
+		if (!tem)
+		    goto no_head;
+		head_xoff = rep_INT (rep_CAR (tem));
+		head_yoff = rep_INT (rep_CDR (tem));
+	    }
+	    else
+	    {
+		/* No head, just centre on the screen. */
+	    no_head:
+		head_xoff = head_yoff = 0;
+		head_width = screen_width;
+		head_height = screen_height;
+	    }
+
+	    x = head_xoff + ((head_width - message.width) / 2);
+	    y = head_yoff + ((head_height - height) / 2);
+	}
+
+	tem = Fassq (Qposition, attrs);
+	if (tem && rep_CONSP(tem))
+	{
+	    tem = rep_CDR(tem);
+	    if (rep_CONSP(tem))
+	    {
+		if (rep_INTP(rep_CAR(tem)))
+		{
+		    x = rep_INT(rep_CAR(tem));
+		    if (x < 0)
+			x += screen_width - message.width;
+		}
+		if (rep_INTP(rep_CDR(tem)))
+		{
+		    y = rep_INT(rep_CDR(tem));
+		    if (y < 0)
+			y += screen_height - height;
+		}
+	    }
+	}
+
+	if (x + message.width > screen_width)
+	    x = MAX (0, screen_width - message.width - 4);
+	else if (x < 4)
+	    x = 4;
+	if (y + height > screen_height)
+	    y = MAX (0, screen_height - height - 4);
+	else if (y < 4)
+	    y = 4;
+
+	if (message_win == 0)
+	{
+	    /* I tried setting save_under in here, but it just slows
+	       down opaque window moves.. */
+	    XSetWindowAttributes attr;
+	    attr.override_redirect = True;
+	    attr.background_pixel = VCOLOR(message.bg)->pixel;
+	    attr.border_pixel = BlackPixel(dpy, screen_num);
+	    attr.event_mask = ExposureMask | ButtonPressMask;
+	    attr.colormap = image_cmap;
+	    message_win = XCreateWindow (dpy, root_window, x, y,
+					 message.width, height, 1,
+					 image_depth, InputOutput,
+					 image_visual,
+					 CWBackPixel | CWBorderPixel
+					 | CWOverrideRedirect | CWEventMask
+					 | CWColormap, &attr);
+	    if (message_win == 0)
+		return Qnil;
+	    register_event_handler (message_win, message_event_handler);
+	    XMapRaised (dpy, message_win);
+	}
+	else
+	{
+	    XWindowChanges attr;
+	    attr.x = x;
+	    attr.y = y;
+	    attr.width = message.width;
+	    attr.height = height;
+	    attr.stack_mode = TopIf;
+	    XConfigureWindow (dpy, message_win,
+			      CWX | CWY | CWWidth | CWHeight | CWStackMode,
+			      &attr);
+	    XSetWindowBackground (dpy, message_win, VCOLOR(message.bg)->pixel);
+	    refresh_message_window ();
+	}
+	return rep_MAKE_INT(message_win);
+    }
+}
+
+
+/* initialisation */
+
+void
+functions_init (void)
+{
+    repv tem;
+
+    tem = rep_push_structure ("sawfish.wm.windows.subrs");
+    rep_ADD_SUBR(Srestack_windows);
+    rep_ADD_SUBR(Sx_raise_window);
+    rep_ADD_SUBR(Sx_lower_window);
+    rep_ADD_SUBR_INT(Sdestroy_window);
+    rep_ADD_SUBR(Smove_window_to);
+    rep_ADD_SUBR(Sresize_window_to);
+    rep_ADD_SUBR(Smove_resize_window_to);
+    rep_pop_structure (tem);
+
+    tem = rep_push_structure ("sawfish.wm.misc");
+    rep_ADD_SUBR(Sx_kill_client);
+    rep_ADD_SUBR(Swarp_cursor);
+    rep_ADD_SUBR(Sgrab_server);
+    rep_ADD_SUBR(Sungrab_server);
+    rep_ADD_SUBR(Sserver_grabbed_p);
+    rep_ADD_SUBR(Sscreen_width);
+    rep_ADD_SUBR(Sscreen_height);
+    rep_ADD_SUBR(Ssync_server);
+    rep_ADD_SUBR(Sdelete_x_property);
+    rep_ADD_SUBR(Slist_x_properties);
+    rep_ADD_SUBR(Sget_x_property);
+    rep_ADD_SUBR(Sset_x_property);
+    rep_ADD_SUBR(Sget_x_text_property);
+    rep_ADD_SUBR(Sset_x_text_property);
+    rep_ADD_SUBR(Screate_window);
+    rep_ADD_SUBR(Sx_atom);
+    rep_ADD_SUBR(Sx_atom_name);
+    rep_ADD_SUBR(Sroot_window_id);
+    rep_ADD_SUBR(Shead_count);
+    rep_ADD_SUBR(Sfind_head);
+    rep_ADD_SUBR(Shead_dimensions);
+    rep_ADD_SUBR(Shead_offset);
+    rep_ADD_SUBR(Sdisplay_message);
+    rep_pop_structure (tem);
+
+    tem = rep_push_structure ("sawfish.wm.events");
+    rep_ADD_SUBR(Sgrab_pointer);
+    rep_ADD_SUBR(Sungrab_pointer);
+    rep_ADD_SUBR(Sgrab_keyboard);
+    rep_ADD_SUBR(Sungrab_keyboard);
+    rep_ADD_SUBR(Ssend_client_message);
+    rep_pop_structure (tem);
+
+    rep_INTERN(root);
+    rep_INTERN_SPECIAL(after_restacking_hook);
+    rep_INTERN(position);
+    rep_INTERN(spacing);
+    rep_INTERN(head);
+
+    rep_mark_static (&message.text);
+    rep_mark_static (&message.fg);
+    rep_mark_static (&message.bg);
+    rep_mark_static (&message.font);
+    rep_mark_static (&message.justify);
+
+#ifdef HAVE_X11_EXTENSIONS_XINERAMA_H
+# ifndef TEST_XINERAMA
+    if (dpy != 0)
+    {
+	if (XineramaQueryExtension (dpy, &xinerama_event_base,
+				    &xinerama_error_base))
+	{
+	    xinerama_head_info = XineramaQueryScreens (dpy, &xinerama_heads);
+	}
+    }
+# else
+    xinerama_head_info = debug_heads;
+    xinerama_heads = debug_nheads;
+# endif
+#endif
+}
+
+void
+functions_kill (void)
+{
+    if (message_win != 0)
+	XDestroyWindow (dpy, message_win);
+}

--- /dev/null
+++ b/src/windows.c
@@ -0,0 +1,1631 @@
+/* windows.c -- window manipulation
+   $Id$
+
+   Copyright (C) 1999 John Harper <[e-mail]>
+
+   This file is part of sawmill.
+
+   sawmill 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, or (at your option)
+   any later version.
+
+   sawmill 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 sawmill; see the file COPYING.   If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "sawmill.h"
+#include <assert.h>
+#include <X11/extensions/shape.h>
+
+Lisp_Window *window_list;
+int window_type;
+
+Lisp_Window *focus_window, *pending_focus_window;
+
+int pending_destroys;
+
+static bool initialising;
+
+DEFSYM(add_window_hook, "add-window-hook");
+DEFSYM(before_add_window_hook, "before-add-window-hook");
+DEFSYM(after_add_window_hook, "after-add-window-hook");
+DEFSYM(place_window_hook, "place-window-hook");
+DEFSYM(placed, "placed");
+DEFSYM(after_framing_hook, "after-framing-hook");
+DEFSYM(after_initialization_hook, "after-initialization-hook");
+DEFSYM(remove_window_hook, "remove-window-hook");
+
+/* for visibility-notify-hook */
+DEFSYM(fully_obscured, "fully-obscured");
+DEFSYM(partially_obscured, "partially-obscured");
+DEFSYM(unobscured, "unobscured");
+
+/* for window-size-hints */
+DEFSYM(min_width, "min-width");
+DEFSYM(min_height, "min-height");
+DEFSYM(max_width, "max-width");
+DEFSYM(max_height, "max-height");
+DEFSYM(width_inc, "width-inc");
+DEFSYM(height_inc, "height-inc");
+DEFSYM(base_width, "base-width");
+DEFSYM(base_height, "base-height");
+DEFSYM(min_aspect, "min-aspect");
+DEFSYM(max_aspect, "max-aspect");
+DEFSYM(user_size, "user-size");
+DEFSYM(program_size, "program-size");
+DEFSYM(user_position, "user-position");
+DEFSYM(program_position, "program-position");
+DEFSYM(window_gravity, "window-gravity");
+
+/* for window-gravity */
+DEFSYM(forget, "forget");
+DEFSYM(static, "static");
+DEFSYM(north_west, "north-west");
+DEFSYM(north, "north");
+DEFSYM(north_east, "north-east");
+DEFSYM(west, "west");
+DEFSYM(center, "center");
+DEFSYM(east, "east");
+DEFSYM(south_west, "south-west");
+DEFSYM(south, "south");
+DEFSYM(south_east, "south-east");
+
+static repv gravity_map[StaticGravity+1];
+
+struct prop_handler {
+    struct prop_handler *next;
+    repv prop;
+    void (*callback) (Lisp_Window *w, repv prop, repv old, repv new);
+};
+
+static struct prop_handler *prop_handlers;
+
+
+/* utilities */
+
+/* Returns true if we should manage window ID */
+bool
+mapped_not_override_p (Window id)
+{
+    XWindowAttributes wa;
+
+    XGetWindowAttributes(dpy, id, &wa);
+    return ((wa.map_state != IsUnmapped) && (wa.override_redirect != True));
+}
+
+/* Returns true if the window's Input hint is set (or defaults to being set) */
+static bool
+window_input_hint_p (Lisp_Window *w)
+{
+    if (w->wmhints != 0 && (w->wmhints->flags & InputHint))
+	return w->wmhints->input;
+    else
+	return TRUE;
+}
+
+static Window queued_focus_id;
+static int queued_focus_revert;
+static Time queued_focus_time;
+
+void
+commit_queued_focus_change (void)
+{
+    if (queued_focus_id != 0)
+    {
+	XSetInputFocus (dpy, queued_focus_id,
+			queued_focus_revert, queued_focus_time);
+	queued_focus_id = 0;
+    }
+}
+
+/* Give the input focus to window W, or to no window if W is null */
+void
+focus_on_window (Lisp_Window *w)
+{
+    if (w != 0 && !WINDOW_IS_GONE_P (w) && w->visible)
+    {
+	Window focus;
+	DB(("focus_on_window (%s)\n", rep_STR(w->name)));
+	if (!w->client_unmapped)
+	{                              
+	    if (w->does_wm_take_focus)
+	    {
+		DB(("  sending WM_TAKE_FOCUS message\n"));
+
+		/* The -1 is an Ugly Hack. The problem is with the case
+		   where the window focuses itself after receiving the
+		   WM_TAKE_FOCUS message. If during the time between us
+		   sending the client message and the window focusing
+		   itself we focused another window using the same
+		   timestamp, the original window (that received the
+		   client message) will still get focused.
+
+		   I'm assuming that it's unlikely that two events will
+		   arrive generating focus changes with timestamps that
+		   only differ by one.. */
+
+		send_client_message (w->id, xa_wm_take_focus,
+				     last_event_time - 1);
+		queued_focus_time = last_event_time - 1;	/* evil */
+
+		/* Only focus on the window if accepts-input is true */
+		if (window_input_hint_p (w))
+		    focus = w->id;
+		else
+		    focus = 0;
+	    }
+	    else
+		focus = w->id;
+	}
+	else
+	    focus = w->frame;
+	if (focus != 0)
+	{
+	    queued_focus_id = focus;
+	    queued_focus_revert = RevertToParent;
+	    queued_focus_time = last_event_time;
+	    pending_focus_window = w;
+	}
+    }
+    else
+    {
+	DB(("focus_on_window (nil)\n"));
+	queued_focus_id = no_focus_window;
+	queued_focus_revert = RevertToNone;
+	queued_focus_time = last_event_time;
+	pending_focus_window = 0;
+    }
+}
+
+/* Should be called when W is no longer focusable. */
+void
+focus_off_window (Lisp_Window *w)
+{
+    if (focus_window == w)
+    {
+	focus_window = 0;
+	if (pending_focus_window == 0 || pending_focus_window == w)
+	    focus_on_window (0);
+    }
+    if (pending_focus_window == w)
+	pending_focus_window = 0;
+}
+
+/* Set flags in W relating to which window manager protocols are recognised
+   by window W. */
+void
+get_window_protocols (Lisp_Window *w)
+{
+    Atom *prot;
+    u_int n;
+    w->does_wm_take_focus = 0;
+    w->does_wm_delete_window = 0;
+    if (XGetWMProtocols (dpy, w->id, &prot, &n) != 0)
+    {
+	int i;
+	for (i = 0; i < n; i++)
+	{
+	    if (prot[i] == xa_wm_take_focus)
+	    {
+		w->does_wm_take_focus = 1;
+		DB(("  WM_TAKE_FOCUS is set\n"));
+	    }
+	    if (prot[i] == xa_wm_delete_window)
+	    {
+		w->does_wm_delete_window = 1;
+		DB(("  WM_DELETE_WINDOW is set\n"));
+	    }
+	}
+	XFree (prot);
+    }
+}
+
+/* These two functions are used to bracket Xlib requests that would map,
+   unmap, or reparent the client window. They ensure that any
+   StructureNotifymask events generated between calling before_local_map ()
+   and after_local_map () are discarded, but no others (so that we don't
+   lose client-generated events) */
+
+void
+before_local_map (Lisp_Window *w)
+{
+    Fgrab_server ();
+    XSelectInput (dpy, w->id, CLIENT_EVENTS & ~StructureNotifyMask);
+}
+
+void
+after_local_map (Lisp_Window *w)
+{
+    XSelectInput (dpy, w->id, CLIENT_EVENTS);
+    Fungrab_server ();
+}
+
+
+/* manipulating the Lisp window structures */
+
+/* Return the window object containing ID, or a null pointer */
+Lisp_Window *
+find_window_by_id (Window id)
+{
+    Lisp_Window *w;
+    w = window_list;
+    while (w != 0 && w->id != id && w->frame != id)
+	w = w->next;
+    if (w != 0 && WINDOW_IS_GONE_P (w))
+	w = 0;
+    if (w != 0)
+    {
+	DB(("find_window_by_id (%lx) --> %s\n", id,
+	    (w->name && rep_STRINGP(w->name))
+	    ? (char *) rep_STR(w->name) : ""));
+    }
+    return w;
+}
+
+/* This is different to the above in that it could return a window
+   that doesn't have a client window. */
+Lisp_Window *
+x_find_window_by_id (Window id)
+{
+    Lisp_Window *w;
+    w = window_list;
+    while (w != 0 && w->saved_id != id && w->frame != id)
+	w = w->next;
+    if (w != 0)
+    {
+	DB(("x_find_window_by_id (%lx) --> %s\n", id,
+	    (w->name && rep_STRINGP(w->name))
+	    ? (char *) rep_STR(w->name) : ""));
+    }
+    return w;
+}
+
+void
+install_window_frame (Lisp_Window *w)
+{
+    DB(("install_window_frame (%s)\n", rep_STR(w->name)));
+    if (!w->reparented && w->frame != 0 && !WINDOW_IS_GONE_P (w))
+    {
+	XSelectInput (dpy, w->frame, FRAME_EVENTS);
+
+	before_local_map (w);
+	XReparentWindow (dpy, w->id, w->frame, -w->frame_x, -w->frame_y);
+	w->reparented = TRUE;
+	after_local_map (w);
+	restack_window (w);
+
+	XAddToSaveSet (dpy, w->id);
+	restack_frame_parts (w);
+	reset_frame_parts (w);
+
+	DB(("  reparented to %lx [%dx%d%+d%+d]\n",
+	    w->frame, w->frame_width, w->frame_height,
+	    w->frame_x, w->frame_y));
+    }
+}
+
+void
+remove_window_frame (Lisp_Window *w)
+{
+    DB(("remove_window_frame (%s)\n", rep_STR(w->name)));
+    if (w->reparented && !WINDOW_IS_GONE_P (w))
+    {
+	/* reparent the subwindow back to the root window */
+
+	before_local_map (w);
+	XReparentWindow (dpy, w->id, root_window, w->attr.x, w->attr.y);
+	w->reparented = FALSE;
+	after_local_map (w);
+	restack_window (w);
+
+	if (!w->mapped)
+	    XRemoveFromSaveSet (dpy, w->id);
+    }
+}
+
+/* Add the top-level window ID to the manager's data structures */
+Lisp_Window *
+add_window (Window id)
+{
+    char *tem;
+    Lisp_Window *w = rep_ALLOC_CELL(sizeof (Lisp_Window));
+    if (w != 0)
+    {
+	rep_GC_root gc_win;
+	repv win = rep_VAL(w);
+	XWindowChanges xwc;
+	u_int xwcm;
+	long supplied;
+	XTextProperty prop;
+
+	DB(("add_window (%lx)\n", id));
+
+	if (id == root_window)
+	    DB(("  ** adding root window!?\n"));
+
+	rep_data_after_gc += sizeof (Lisp_Window);
+	memset (w, 0, sizeof (Lisp_Window));
+
+	/* First initialise the Lisp stuff.. */
+	w->next = window_list;
+	window_list = w;
+	w->car = window_type;
+	w->id = id;
+	w->saved_id = id;
+	w->plist = Qnil;
+	w->frame_style = Qnil;;
+	w->icon_image = rep_NULL;
+
+	/* have to put it somewhere until it finds the right place */
+	insert_in_stacking_list_above_all (w);
+	restack_window (w);
+
+	/* ..now do the X11 stuff */
+
+	XSelectInput (dpy, id, CLIENT_EVENTS);
+	XGetWindowAttributes (dpy, id, &w->attr);
+	DB(("  orig: width=%d height=%d x=%d y=%d\n",
+	    w->attr.width, w->attr.height, w->attr.x, w->attr.y));
+
+	if (XGetWMName (dpy, id, &prop) && prop.value)
+	{
+	    if (prop.nitems > 0)
+	    {
+		char **list;
+		int count;
+		prop.nitems = strlen(prop.value);
+		if (XmbTextPropertyToTextList (dpy, &prop, &list, &count)
+		    >= Success)
+		{
+		    if (count > 0)
+			w->name = rep_string_dup (list[0]);
+		    XFreeStringList (list);
+		}
+	    }
+	    XFree (prop.value);
+	}
+	if (w->name == 0)
+	    w->name = rep_null_string ();
+	w->full_name = w->name;
+	if (XGetIconName (dpy, id, &tem))
+	{
+	    w->icon_name = rep_string_dup (tem);
+	    XFree (tem);
+	}
+	else
+	    w->icon_name = w->name;
+
+	w->wmhints = XGetWMHints (dpy, id);
+	if (!XGetWMNormalHints (dpy, w->id, &w->hints, &supplied))
+	    w->hints.flags = 0;
+	get_window_protocols (w);
+	if (!XGetTransientForHint (dpy, w->id, &w->transient_for_hint))
+	    w->transient_for_hint = 0;
+	if (!XGetWMColormapWindows (dpy, w->id,
+				    &w->cmap_windows, &w->n_cmap_windows))
+	{
+	    w->n_cmap_windows = 0;
+	}
+
+	{
+	    /* Is the window shaped? */
+	    int xws, yws, xbs, ybs;
+	    u_int wws, hws, wbs, hbs;
+	    int bounding, clip;
+	    XShapeSelectInput (dpy, w->id, ShapeNotifyMask);
+	    XShapeQueryExtents (dpy, w->id, &bounding, &xws, &yws, &wws, &hws,
+				&clip, &xbs, &ybs, &wbs, &hbs);
+	    w->shaped = bounding ? 1 : 0;
+	}
+
+	DB(("  name=`%s' x=%d y=%d width=%d height=%d\n",
+	    rep_STR(w->name), w->attr.x, w->attr.y,
+	    w->attr.width, w->attr.height));
+
+	xwcm = CWX | CWX | CWWidth | CWHeight | CWBorderWidth;
+	xwc.x = w->attr.x;
+	xwc.y = w->attr.y;
+	xwc.width = w->attr.width;
+	xwc.height = w->attr.height;
+	xwc.border_width = 0;
+	XConfigureWindow (dpy, id, xwcm, &xwc);
+
+        w->visible = TRUE;
+	w->mapped = TRUE;		/* only called from map request */
+
+	if (initialising)
+	    Fwindow_put (rep_VAL (w), Qplaced, Qt);
+
+	/* ..then call the add-window-hook's.. */
+	rep_PUSHGC(gc_win, win);
+	Fcall_window_hook (Qbefore_add_window_hook, rep_VAL(w), Qnil, Qnil);
+	Fcall_window_hook (Qadd_window_hook, rep_VAL(w), Qnil, Qnil);
+	rep_POPGC;
+
+	/* In case the window disappeared during the hook call */
+	if (!WINDOW_IS_GONE_P (w))
+	{
+	    Fgrab_server ();
+
+	    /* this is where we create and reparent the window frame */
+	    create_window_frame (w);
+	    install_window_frame (w);
+
+	    /* this grabs bound events in the subwindow */
+	    grab_window_events (w, TRUE);
+
+	    Fungrab_server ();
+	}
+	else
+	    emit_pending_destroys ();
+
+	if (!WINDOW_IS_GONE_P (w))
+	{
+	    repv tem = Fwindow_get (rep_VAL(w), Qplaced);
+	    if (initialising || (tem && tem == Qnil))
+	    {
+		/* ..then the place-window-hook.. */
+		rep_PUSHGC(gc_win, win);
+		Fcall_window_hook (Qplace_window_hook, rep_VAL(w), Qnil, Qor);
+		rep_POPGC;
+	    }
+	}
+	Fwindow_put (rep_VAL(w), Qplaced, Qt);
+
+	if (!WINDOW_IS_GONE_P (w))
+	    Fcall_window_hook (Qafter_add_window_hook, rep_VAL(w), Qnil, Qnil);
+
+	if (!WINDOW_IS_GONE_P (w))
+	{
+	    /* Tell the window where it ended up.. */
+	    send_synthetic_configure (w);
+	}
+    }
+    return w;
+}
+
+/* Remove W from the managed windows. If DESTROYED is nil, then the
+   window will be reparented back to the root window */
+void
+remove_window (Lisp_Window *w, repv destroyed, repv from_error)
+{
+    DB(("remove_window (%s, %s)\n",
+	rep_STR(w->name), destroyed == Qnil ? "nil" : "t"));
+
+    if (w->id != 0)
+    {
+	if (destroyed == Qnil && from_error == Qnil)
+	{
+	    grab_window_events (w, FALSE);
+	    remove_window_frame (w);
+
+	    /* Restore original border width of the client */
+	    XSetWindowBorderWidth (dpy, w->id, w->attr.border_width);
+	}
+
+	if (from_error == Qnil)
+	    destroy_window_frame (w, FALSE);
+
+	if (!WINDOW_IS_GONE_P (w))
+	    remove_from_stacking_list (w);
+
+	w->id = 0;
+	pending_destroys++;
+
+	/* gc will do the rest... */
+    }
+    else if (w->frame != 0 && from_error == Qnil)
+	destroy_window_frame (w, FALSE);
+
+    /* We can lose the focus sometimes, notably after a was-focused
+       window is closed while a keyboard grab exists.. (netscape) */
+    if (from_error == Qnil)
+    {
+	Window focus;
+	int revert_to;
+	XGetInputFocus (dpy, &focus, &revert_to);
+	if (focus == None || focus == PointerRoot)
+	{
+	    DB (("lost focus (%ld)\n", focus));
+	    focus_on_window (pending_focus_window
+			     ? pending_focus_window : focus_window);
+	}
+    }
+}
+
+void
+fix_window_size (Lisp_Window *w)
+{
+    Fgrab_server ();
+    if (w->frame != 0 && w->rebuild_frame != 0)
+	w->rebuild_frame (w);
+    else
+	XResizeWindow (dpy, w->id, w->attr.width, w->attr.height);
+    Fungrab_server ();
+}
+
+/* Call destroy-notify-hook on any newly-dead windows */
+void
+emit_pending_destroys (void)
+{
+    if (pending_destroys > 0)
+    {
+	Lisp_Window *w;
+    again:
+	for (w = window_list; w != 0 && !rep_INTERRUPTP; w = w->next)
+	{
+	    if (WINDOW_IS_GONE_P (w) && !w->destroyed)
+	    {
+		w->destroyed = 1;
+		Fcall_window_hook (Qdestroy_notify_hook,
+				   rep_VAL(w), Qnil, Qnil);
+
+		focus_off_window (w);
+
+		/* gc may have reordered the list, so we have to start
+		   at the beginning again.. */
+		goto again;
+	    }
+	}
+    }
+    pending_destroys = 0;
+}
+
+
+/* Lisp functions */
+
+DEFUN("window-get", Fwindow_get, Swindow_get,
+      (repv win, repv prop), rep_Subr2) /*
+::doc:sawfish.wm.windows.subrs#window-get::
+window-get WINDOW PROPERTY
+
+Return the value of the property named PROPERTY (a symbol) of WINDOW.
+
+Note that these are Lisp properties not X properties.
+::end:: */
+{
+    repv plist;
+    rep_DECLARE1(win, XWINDOWP);
+    plist = VWIN(win)->plist;
+    while (rep_CONSP(plist) && rep_CONSP(rep_CDR(plist)))
+    {
+	if (rep_CAR(plist) == prop
+	    || (!rep_SYMBOLP(prop)
+		&& rep_value_cmp (rep_CAR(plist), prop) == 0))
+	{
+	    return rep_CAR(rep_CDR(plist));
+	}
+	plist = rep_CDR(rep_CDR(plist));
+    }
+    return Qnil;
+}
+
+DEFUN("map-window-properties", Fmap_window_properties,
+      Smap_window_properties, (repv fun, repv win), rep_Subr2) /*
+::doc:sawfish.wm.windows.subrs#map-window-properties::
+map-window-properties FUNCTION WINDOW
+
+Call (FUNCTION PROPERTY VALUE) for all Lisp properties set on window
+object WINDOW.
+::end:: */
+{
+    repv ret = Qnil, plist;
+    rep_GC_root gc_plist, gc_fun;
+    rep_DECLARE2 (win, XWINDOWP);
+    plist = VWIN(win)->plist;
+    rep_PUSHGC (gc_plist, plist);
+    rep_PUSHGC (gc_fun, fun);
+    while (rep_CONSP(plist) && rep_CONSP(rep_CDR(plist)))
+    {
+	ret = rep_call_lisp2 (fun, rep_CAR (plist), rep_CADR (plist));
+	if (ret == rep_NULL)
+	    break;
+	plist = rep_CDDR (plist);
+    }
+    rep_POPGC; rep_POPGC;
+    return ret;
+}
+
+void
+register_property_monitor (repv prop,
+			   void (*callback) (Lisp_Window *, repv, repv, repv))
+{
+    struct prop_handler *ph = rep_alloc (sizeof (struct prop_handler));
+    ph->next = prop_handlers;
+    prop_handlers = ph;
+    ph->prop = prop;
+    ph->callback = callback;
+}    
+
+DEFUN("window-put", Fwindow_put, Swindow_put,
+      (repv win, repv prop, repv val), rep_Subr3) /*
+::doc:sawfish.wm.windows.subrs#window-put::
+window-put WINDOW PROPERTY VALUE
+
+Set the value of the property named PROPERTY (a symbol) of WINDOW to VALUE.
+
+Note that these are Lisp properties not X properties.
+::end:: */
+{
+    repv plist;
+    rep_DECLARE1(win, XWINDOWP);
+    plist = VWIN(win)->plist;
+    while (rep_CONSP(plist) && rep_CONSP(rep_CDR(plist)))
+    {
+	if (rep_CAR(plist) == prop
+	    || (!rep_SYMBOLP(prop)
+		&& rep_value_cmp (rep_CAR(plist), prop) == 0))
+	{
+	    struct prop_handler *ph;
+	    for (ph = prop_handlers; ph != 0; ph = ph->next)
+	    {
+		repv old = rep_CADR (plist);
+		if (ph->prop == prop && old != val)
+		    ph->callback (VWIN (win), prop, old, val);
+	    }
+	    rep_CAR(rep_CDR(plist)) = val;
+	    return val;
+	}
+	plist = rep_CDR(rep_CDR(plist));
+    }
+    plist = Fcons(prop, Fcons(val, VWIN(win)->plist));
+    if (plist != rep_NULL)
+	VWIN(win)->plist = plist;
+    return val;
+}
+
+DEFUN("window-name", Fwindow_name, Swindow_name, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-name::
+window-name WINDOW
+
+Return the name of window object WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->name;
+}
+
+DEFUN("window-full-name", Fwindow_full_name, Swindow_full_name,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-full-name::
+window-full-name WINDOW
+
+Return the full name of window object WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->full_name;
+}
+
+DEFUN("window-icon-name", Fwindow_icon_name, Swindow_icon_name,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-icon-name::
+window-icon-name WINDOW
+
+Return the name of window object WINDOW's icon.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->icon_name;
+}
+
+DEFUN("window-mapped-p", Fwindow_mapped_p, Swindow_mapped_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-mapped-p::
+window-mapped-p WINDOW
+
+Return t if the client window associated with object WINDOW is mapped.
+(This doesn't necessarily mean that it is visible.)
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->mapped ? Qt : Qnil;
+}
+
+DEFUN("window-frame", Fwindow_frame, Swindow_frame, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-frame::
+window-frame WINDOW
+
+Return the frame object associated with WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->frame_style;
+}
+
+DEFUN("set-window-frame", Fset_window_frame, Sset_window_frame,
+      (repv win, repv frame), rep_Subr2) /*
+::doc:sawfish.wm.windows.subrs#set-window-frame::
+set-window-frame WINDOW FRAME
+
+Set the frame associated with the window object WINDOW to FRAME (a
+list). If the window is mapped the old frame will be destroyed and a
+new frame constructed as specified by FRAME.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    rep_DECLARE2(frame, rep_LISTP);
+    Fgrab_server ();
+
+    if (VWIN(win)->reparented)
+	destroy_window_frame (VWIN(win), TRUE);
+
+    VWIN(win)->frame_style = frame;
+
+    if (VWIN(win)->reparented)
+	create_window_frame (VWIN(win));
+
+    Fungrab_server ();
+    Fcall_window_hook (Qafter_framing_hook, win, Qnil, Qnil);
+    return VWIN(win)->frame_style;
+}
+
+DEFUN("rebuild-frame", Frebuild_frame, Srebuild_frame, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#rebuild-frame::
+rebuild-frame WINDOW
+
+Reinitialises and recalibrates the window frame of WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    if (VWIN(win)->frame != 0 && VWIN(win)->rebuild_frame != 0)
+    {
+	VWIN(win)->rebuild_frame (VWIN(win));
+	refresh_frame_parts (VWIN(win));
+	Fcall_window_hook (Qafter_framing_hook, win, Qnil, Qnil);
+    }
+    return win;
+}
+
+DEFUN("window-position", Fwindow_position, Swindow_position,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-position::
+window-position WINDOW
+
+Return (X . Y) defining the current position of WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return Fcons (rep_MAKE_INT(VWIN(win)->attr.x),
+		  rep_MAKE_INT(VWIN(win)->attr.y));
+}
+
+DEFUN("window-dimensions", Fwindow_dimensions, Swindow_dimensions,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-dimensions::
+window-dimensions WINDOW
+
+Return (WIDTH . HEIGHT) defining the current dimensions of the client
+window associated with WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return Fcons (rep_MAKE_INT(VWIN(win)->attr.width),
+		  rep_MAKE_INT(VWIN(win)->attr.height));
+}
+
+DEFUN("window-frame-dimensions", Fwindow_frame_dimensions,
+      Swindow_frame_dimensions, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-frame-dimensions::
+window-frame-dimensions WINDOW
+
+Return (WIDTH . HEIGHT) defining the current dimensions of the frame
+surrounding WINDOW.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    if (VWIN(win)->reparented)
+    {
+	return Fcons (rep_MAKE_INT(VWIN(win)->frame_width),
+		      rep_MAKE_INT(VWIN(win)->frame_height));
+    }
+    else
+	return Fwindow_dimensions (win);
+}
+
+DEFUN("window-frame-offset", Fwindow_frame_offset,
+      Swindow_frame_offset, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-frame-offset::
+window-frame-offset WINDOW
+
+Return (X . Y) defining the offset from the origin of the client window
+associated with WINDOW to its frame window.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return Fcons (rep_MAKE_INT(VWIN(win)->frame_x),
+		  rep_MAKE_INT(VWIN(win)->frame_y));
+}
+
+DEFUN("windowp", Fwindowp, Swindowp, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#windowp::
+windowp ARG
+
+Return t if ARG is a window object.
+::end:: */
+{
+    return WINDOWP(win) ? Qt : Qnil;
+}
+
+DEFUN("set-input-focus", Fset_input_focus, Sset_input_focus,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#set-input-focus::
+set-input-focus WINDOW
+
+Set the input focus to WINDOW. If WINDOW is nil, then no window will
+have the focus.
+::end:: */
+{
+    if (win != Qnil && win != Qroot)
+    {
+	rep_DECLARE1(win, WINDOWP);
+	focus_on_window (VWIN(win));
+    }
+    else
+	focus_on_window (0);
+    return win;
+}
+
+DEFUN("input-focus", Finput_focus, Sinput_focus, (void), rep_Subr0) /*
+::doc:sawfish.wm.windows.subrs#input-focus::
+input-focus
+
+Return the window object that has the input focus, or nil if none does.
+::end:: */
+{
+    return (focus_window == 0) ? Qnil : rep_VAL(focus_window);
+}
+
+DEFUN("window-wants-input-p", Fwindow_wants_input_p, Swindow_wants_input_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-wants-input-p::
+window-wants-input-p WINDOW
+
+Return t if the client window associated with object WINDOW has hinted
+that it would like to be given the input focus when applicable.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    if (VWIN(win)->does_wm_take_focus)
+	return Qt;
+    else
+	return window_input_hint_p (VWIN (win)) ? Qt : Qnil;
+}
+
+DEFUN("managed-windows", Fmanaged_windows, Smanaged_windows,
+      (void), rep_Subr0) /*
+::doc:sawfish.wm.windows.subrs#managed-windows::
+managed-windows
+
+Return a list of all known client window objects.
+::end:: */
+{
+    repv list = Qnil;
+    Lisp_Window *w = window_list;
+    while (w != 0)
+    {
+	if (!WINDOW_IS_GONE_P (w))
+	    list = Fcons (rep_VAL(w), list);
+	w = w->next;
+    }
+    return list;
+}
+
+DEFUN("get-window-by-id", Fget_window_by_id, Sget_window_by_id,
+      (repv id), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#get-window-by-id::
+get-window-by-id ID
+
+Return the window object associated with xid ID, or nil.
+::end:: */
+{
+    Lisp_Window *w;
+    rep_DECLARE1(id, rep_INTEGERP);
+    w = find_window_by_id (rep_get_long_uint (id));
+    return w ? rep_VAL(w) : Qnil;
+}
+
+DEFUN("stacking-order", Fstacking_order, Sstacking_order, (void), rep_Subr0) /*
+::doc:sawfish.wm.windows.subrs#stacking-order::
+stacking-order
+
+Return a list of windows defining the current stacking order of all
+client windows.
+::end:: */
+{
+    return make_stacking_list ();
+}
+
+DEFUN("window-visibility", Fwindow_visibility, Swindow_visibility,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-visibility::
+window-visibility WINDOW
+
+Return a symbol defining the visibility of WINDOW. Possible returned
+symbols are `fully-obscured', `partially-obscured' or `unobscured'.
+::end:: */
+{
+    repv sym = Qnil;
+    rep_DECLARE1(win, WINDOWP);
+    switch (VWIN(win)->frame_vis)
+    {
+    case VisibilityFullyObscured:
+	sym = Qfully_obscured;
+	break;
+
+    case VisibilityPartiallyObscured:
+	sym = Qpartially_obscured;
+	break;
+
+    case VisibilityUnobscured:
+	sym = Qunobscured;
+	break;
+    }
+    return sym;
+}
+
+DEFUN("window-transient-p", Fwindow_transient_p, Swindow_transient_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-transient-p::
+window-transient-p WINDOW
+
+Return non-nil if WINDOW is a transient window. The returned value will
+then be the numeric id of its parent window.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return (VWIN(win)->transient_for_hint
+	    ? rep_MAKE_INT(VWIN(win)->transient_for_hint) : Qnil);
+}
+
+DEFUN("window-urgent-p", Fwindow_urgent_p, Swindow_urgent_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-urgent-p::
+window-urgent-p WINDOW
+
+Return true if the `Urgency' hint of the window associated with WINDOW
+is set.
+::end:: */
+{
+    rep_DECLARE1 (win, WINDOWP);
+    return ((VWIN (win)->wmhints
+	     && VWIN (win)->wmhints->flags & XUrgencyHint) ? Qt : Qnil);
+}
+
+DEFUN("window-shaped-p", Fwindow_shaped_p, Swindow_shaped_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-shaped-p::
+window-shaped-p WINDOW
+
+Return non-nil if WINDOW is shaped.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->shaped ? Qt : Qnil;
+}
+
+DEFUN("hide-window", Fhide_window, Shide_window, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#hide-window::
+hide-window WINDOW
+
+Prevent WINDOW from being displayed. See `show-window'.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    if (VWIN(win)->visible)
+    {
+	if (VWIN(win)->mapped)
+	{
+	    if (VWIN(win)->frame)
+		XUnmapWindow (dpy, VWIN(win)->frame);
+	    if (!VWIN(win)->client_unmapped)
+	    {
+		before_local_map (VWIN(win));
+		XUnmapWindow (dpy, VWIN(win)->id);
+		VWIN(win)->client_unmapped = 1;
+		after_local_map (VWIN(win));
+	    }
+	}
+	VWIN(win)->visible = 0;
+	reset_frame_parts (VWIN(win));
+    }
+    return win;
+}
+
+DEFUN("show-window", Fshow_window, Sshow_window, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#show-window::
+show-window WINDOW
+
+Ensure that WINDOW (if it has been mapped) is visible. See `hide-window'.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    if (!VWIN(win)->visible)
+    {
+	if (VWIN(win)->mapped)
+	{
+	    if (VWIN(win)->client_unmapped && !VWIN(win)->client_hidden)
+	    {
+		before_local_map (VWIN(win));
+		XMapWindow (dpy, VWIN(win)->id);
+		VWIN(win)->client_unmapped = 0;
+		after_local_map (VWIN(win));
+	    }
+	    if (VWIN(win)->frame)
+		XMapWindow (dpy, VWIN(win)->frame);
+	}
+	VWIN(win)->visible = 1;
+    }
+    return win;
+}
+
+DEFUN("window-visible-p", Fwindow_visible_p, Swindow_visible_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-visible-p::
+window-visible-p WINDOW
+
+Return t if WINDOW is currently visible (i.e. not hidden, see `hide-window').
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->visible ? Qt : Qnil;
+}
+
+DEFUN("window-framed-p", Fwindow_framed_p, Swindow_framed_p,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-framed-p::
+window-framed-p WINDOW
+
+Return t if WINDOW has been reparented to a frame window.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->reparented ? Qt : Qnil;
+}
+
+DEFUN("window-id", Fwindow_id, Swindow_id, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-id::
+window-id WINDOW
+
+Return the numeric id of the client window associated with object
+WINDOW. Returns nil if the client window has been deleted.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return VWIN(win)->id ? rep_MAKE_INT (VWIN(win)->id) : Qnil;
+}
+
+DEFUN("window-group-id", Fwindow_group_id, Swindow_group_id,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-group-id::
+window-group-id WINDOW
+
+Return the numeric id defining the leader of the group that WINDOW is a
+member of, or nil if it is not a member of a group.
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    if (VWIN(win)->wmhints == 0)
+	return Qnil;
+    return ((VWIN(win)->wmhints->flags & WindowGroupHint)
+	    ? rep_MAKE_INT (VWIN(win)->wmhints->window_group)
+	    : Qnil);
+}
+
+DEFUN("window-border-width", Fwindow_border_width, Swindow_border_width,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-border-width::
+window-border-width WINDOW
+::end:: */
+{
+    rep_DECLARE1(win, WINDOWP);
+    return rep_MAKE_INT(VWIN(win)->attr.border_width);
+}
+
+DEFUN("window-size-hints", Fwindow_size_hints, Swindow_size_hints,
+      (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-size-hints::
+window-size-hints WINDOW
+
+Return an alist defining the size-hints specified by the client window
+associated with WINDOW. Possible keys in the alist are `min-height',
+`max-height', `min-width', `max-width', `height-inc', `width-inc',
+`min-aspect', `max-aspect', `base-height', `base-width',
+`user-position', `program-position', `user-size', `program-size',
+`window-gravity', `border-size'.
+::end:: */
+{
+    repv ret = Qnil;
+    XSizeHints *hints;
+    long flags;
+    rep_DECLARE1(win, WINDOWP);
+
+    hints = &VWIN(win)->hints;
+    flags = hints->flags;
+
+    /* Some sanity checking */
+    if ((flags & PMinSize) 
+	&& (hints->min_width <= 0 || hints->min_height <= 0))
+	flags &= ~PMinSize;
+    if ((flags & PMaxSize)
+	&& (hints->max_width <= 0 || hints->max_height <= 0))
+	flags &= ~PMaxSize;
+    if ((flags & PResizeInc)
+	&& (hints->width_inc <= 0 || hints->width_inc <= 0))
+	flags &= ~PResizeInc;
+    if ((flags & PBaseSize)
+	&& (hints->base_width <= 0 || hints->base_height <= 0))
+	flags &= ~PBaseSize;
+
+    if (flags & PMinSize)
+    {
+	ret = Fcons (Fcons (Qmin_width, rep_MAKE_INT(hints->min_width)),
+		     Fcons (Fcons (Qmin_height,
+				   rep_MAKE_INT(hints->min_height)), ret));
+    }
+    if (flags & PMaxSize)
+    {
+	ret = Fcons (Fcons (Qmax_width, rep_MAKE_INT(hints->max_width)),
+		     Fcons (Fcons (Qmax_height,
+				   rep_MAKE_INT(hints->max_height)), ret));
+    }
+    if (flags & PResizeInc)
+    {
+	ret = Fcons (Fcons (Qwidth_inc, rep_MAKE_INT(hints->width_inc)),
+		     Fcons (Fcons (Qheight_inc,
+				   rep_MAKE_INT(hints->height_inc)), ret));
+    }
+    if (flags & PBaseSize)
+    {
+	ret = Fcons (Fcons (Qbase_width, rep_MAKE_INT(hints->base_width)),
+		     Fcons (Fcons (Qbase_height,
+				   rep_MAKE_INT(hints->base_height)), ret));
+    }
+    if (flags & PAspect)
+    {
+	ret = Fcons (Fcons (Qmin_aspect,
+			    Fcons (rep_MAKE_INT(hints->min_aspect.x),
+				   rep_MAKE_INT(hints->min_aspect.y))),
+		     Fcons (Fcons (Qmax_aspect,
+				   Fcons (rep_MAKE_INT(hints->max_aspect.x),
+					  rep_MAKE_INT(hints->max_aspect.y))),
+			    ret));
+    }
+    if (flags & USPosition)
+	ret = Fcons (Fcons (Quser_position, Qt), ret);
+    else if (flags & PPosition)
+	ret = Fcons (Fcons (Qprogram_position, Qt), ret);
+    if (flags & USSize)
+	ret = Fcons (Fcons (Quser_size, Qt), ret);
+    else if (flags & PSize)
+	ret = Fcons (Fcons (Qprogram_size, Qt), ret);
+    if ((flags & PWinGravity)
+	&& hints->win_gravity >= ForgetGravity
+	&& hints->win_gravity <= StaticGravity)
+    {
+	ret = Fcons (Fcons (Qwindow_gravity,
+			    gravity_map[hints->win_gravity]), ret);
+    }
+    return ret;
+}
+
+DEFUN("call-window-hook", Fcall_window_hook, Scall_window_hook,
+      (repv hook, repv win, repv args, repv type), rep_Subr4) /*
+::doc:sawfish.wm.windows.subrs#call-window-hook::
+call-window-hook HOOK WINDOW &optional ARGS HOOK-TYPE
+
+Call HOOK for WINDOW with extra arguments ARGS. See `call-hook' for a
+description of HOOK-TYPE.
+::end:: */
+{
+    repv tem;
+    rep_GC_root gc_hook, gc_args, gc_type;
+    rep_DECLARE1(hook, rep_SYMBOLP);
+    rep_DECLARE2(win, XWINDOWP);
+    args = Fcons (win, args);
+    rep_PUSHGC(gc_hook, hook);
+    rep_PUSHGC(gc_args, args);
+    rep_PUSHGC(gc_type, type);
+    tem = Fwindow_get (win, hook);
+    if (tem && tem != Qnil)
+    {
+	tem = Fcall_hook (tem, args, type);
+	if (!tem || (type == Qand && tem == Qnil)
+	    || (type == Qor && tem != Qnil))
+	{
+	    goto out;
+	}
+    }
+    tem = Fcall_hook (hook, args, type);
+out:
+    rep_POPGC; rep_POPGC; rep_POPGC;
+    return tem;
+}
+
+DEFUN("window-icon-image", Fwindow_icon_image,
+      Swindow_icon_image, (repv win), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#window-icon-image::
+window-icon-image WINDOW
+
+Returns an image object representing the icon currently associated with
+WINDOW. Returns the symbol `nil' if no such image.
+::end:: */
+{
+   rep_DECLARE1 (win, WINDOWP);
+
+   if (VWIN (win)->icon_image == rep_NULL)
+   {
+       Window pixmap_id = 0, mask_id = 0;
+
+       if (VWIN (win)->wmhints != 0)
+       {
+	   if (VWIN (win)->wmhints->flags & IconPixmapHint
+	       && VWIN (win)->wmhints->icon_pixmap != 0)
+	   {
+	       pixmap_id = VWIN (win)->wmhints->icon_pixmap;
+	   }
+
+	   if (VWIN (win)->wmhints->flags & IconMaskHint
+	       && VWIN (win)->wmhints->icon_mask != 0)
+	   {
+	       mask_id = VWIN (win)->wmhints->icon_mask;
+	   }
+       }
+
+       if (pixmap_id == 0 && !WINDOW_IS_GONE_P (VWIN (win)))
+       {
+	   Atom actual_type;
+	   int actual_format;
+	   long nitems, bytes_after;
+	   u_long *data = 0;
+
+	   static Atom kwm_win_icon = 0;
+
+	   if (kwm_win_icon == 0)
+	       kwm_win_icon = XInternAtom (dpy, "KWM_WIN_ICON", False);
+
+	   if (XGetWindowProperty (dpy, VWIN (win)->id, kwm_win_icon,
+				   0, 2, False, kwm_win_icon,
+				   &actual_type, &actual_format,
+				   &nitems, &bytes_after,
+				   (u_char **) &data) == Success
+	       && actual_type == kwm_win_icon
+	       && bytes_after == 0)
+	   {
+	       pixmap_id = data[0];
+	       mask_id = data[1];
+	   }
+	   if (data != 0)
+	       XFree (data);
+       }
+
+       VWIN (win)->icon_image = Qnil;
+
+       if (pixmap_id != 0)
+       {
+	   VWIN (win)->icon_image = (Fmake_image_from_x_drawable
+				     (rep_MAKE_INT (pixmap_id),
+				      mask_id ? rep_MAKE_INT (mask_id) : Qnil));
+       }
+   }
+
+   return VWIN (win)->icon_image;
+}
+
+DEFUN ("map-windows", Fmap_windows, Smap_windows, (repv fun), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#map-windows::
+map-windows FUN
+
+Map the single-parameter function FUN over all existing windows.
+::end:: */
+{
+    repv w;
+    rep_GC_root gc_fun, gc_w;
+    repv ret = Qnil;
+
+    rep_PUSHGC (gc_fun, fun);
+    rep_PUSHGC (gc_w, w);
+    for (w = rep_VAL (window_list); w != rep_NULL; w = rep_VAL (VWIN(w)->next))
+    {
+	if (!WINDOW_IS_GONE_P (VWIN (w)))
+	{
+	    ret = rep_call_lisp1 (fun, w);
+	    if (ret == rep_NULL)
+		break;
+	}
+    }
+    rep_POPGC; rep_POPGC;
+    return ret;
+}
+
+DEFUN ("filter-windows", Ffilter_windows,
+       Sfilter_windows, (repv pred), rep_Subr1) /*
+::doc:sawfish.wm.windows.subrs#filter-windows::
+filter-windows PRED
+
+Return the list of windows that match the predicate function PRED.
+::end:: */
+{
+    repv w, output = Qnil, *ptr = &output;
+    rep_GC_root gc_pred, gc_w, gc_output;
+
+    rep_PUSHGC(gc_pred, pred);
+    rep_PUSHGC(gc_w, w);
+    rep_PUSHGC(gc_output, output);
+    for (w = rep_VAL (window_list); w != rep_NULL; w = rep_VAL (VWIN(w)->next))
+    {
+	if (!WINDOW_IS_GONE_P (VWIN (w)))
+	{
+	    repv tem = rep_call_lisp1 (pred, w);
+	    if (tem == rep_NULL)
+	    {
+		output = rep_NULL;
+		break;
+	    }
+	    if (tem != Qnil)
+	    {
+		*ptr = Fcons (w, Qnil);
+		ptr = rep_CDRLOC (*ptr);
+	    }
+	}
+    }
+    rep_POPGC; rep_POPGC; rep_POPGC;
+    return output;
+}
+
+
+/* type hooks */
+
+static int
+window_cmp (repv w1, repv w2)
+{
+    return w1 != w2;
+}
+
+static void
+window_prin (repv stream, repv win)
+{
+    char buf[128];
+    sprintf (buf, "#<window %lx>", VWIN(win)->id);
+    rep_stream_puts (stream, buf, -1, FALSE);
+}
+
+static void
+window_mark (repv win)
+{
+    rep_MARKVAL(VWIN(win)->plist);
+    rep_MARKVAL(VWIN(win)->frame_style);
+    mark_frame_parts (VWIN(win));
+    rep_MARKVAL(VWIN(win)->name);
+    rep_MARKVAL(VWIN(win)->full_name);
+    rep_MARKVAL(VWIN(win)->icon_name);
+    rep_MARKVAL(VWIN(win)->icon_image);
+}
+
+static void
+window_mark_type (void)
+{
+    Lisp_Window *w;
+    struct prop_handler *ph;
+    for (w = window_list; w != 0; w = w->next)
+    {
+	if (!WINDOW_IS_GONE_P (w) || !w->destroyed)
+	    rep_MARKVAL(rep_VAL(w));
+    }
+    for (ph = prop_handlers; ph != 0; ph = ph->next)
+	rep_MARKVAL (ph->prop);
+    rep_MARKVAL (rep_VAL (focus_window));
+}
+
+static void
+window_sweep (void)
+{
+    Lisp_Window **ptr = &window_list;
+    while (*ptr != 0)
+    {
+	Lisp_Window *w = *ptr;
+	if (!rep_GC_CELL_MARKEDP(rep_VAL(w)))
+	{
+	    assert (!window_in_stacking_list_p (w));
+	    destroy_window_frame (w, FALSE);
+	    if (w->wmhints != 0)
+		XFree (w->wmhints);
+	    if (w->n_cmap_windows > 0)
+		XFree (w->cmap_windows);
+	    *ptr = w->next;
+	    rep_FREE_CELL(w);
+	}
+	else
+	{
+	    ptr = &(w->next);
+	    rep_GC_CLR_CELL(rep_VAL(w));
+	}
+    }
+}
+
+
+/* initialisation */
+
+void
+manage_windows (void)
+{
+    Window root, parent, *children, focus;
+    unsigned int nchildren, i;
+    int revert_to;
+
+    Fgrab_server ();
+
+    XGetInputFocus (dpy, &focus, &revert_to);
+    if (focus == PointerRoot)
+    {
+    	Window root, child;
+	Bool found;
+	int rx, ry, wx, wy;
+	unsigned mask;
+
+	found = XQueryPointer (dpy, DefaultRootWindow(dpy), &root,
+			       &child, &rx, &ry, &wx, &wy, &mask);
+	if (!found)
+	{
+	    found = XQueryPointer (dpy, root, &root, &child,
+				   &rx, &ry, &wx, &wy, &mask);
+	}
+	focus = child;
+    }
+
+    XQueryTree (dpy, root_window, &root, &parent, &children, &nchildren);
+    initialising = TRUE;
+    for (i = 0; i < nchildren; i++)
+    {
+	if (mapped_not_override_p (children[i]))
+	{
+	    XEvent fake;
+	    Lisp_Window *w;
+	    fake.xmaprequest.window = children[i];
+	    /* Make sure the window is initially unmapped. We expect to
+	       get map-notify events when we later remap it.. #67601 */
+	    XUnmapWindow (dpy, children[i]);
+	    map_request (&fake);
+	    w = find_window_by_id (children[i]);
+	}
+    }
+    initialising = FALSE;
+    if (nchildren > 0)
+	XFree (children);
+
+    /* Try to keep the current focus state. */
+    focus_on_window (0);
+    if (focus != None)
+    {
+	Lisp_Window *w = find_window_by_id (focus);
+	if (w != 0)
+	    focus_on_window (w);
+    }
+
+    Fungrab_server ();
+    Fcall_hook (Qafter_initialization_hook, Qnil, Qnil);
+}
+
+void
+windows_init (void)
+{
+    repv tem;
+    window_type = rep_register_new_type ("window", window_cmp, window_prin,
+					 window_prin, window_sweep,
+					 window_mark, window_mark_type,
+					 0, 0, 0, 0, 0, 0);
+
+    tem = rep_push_structure ("sawfish.wm.windows.subrs");
+    rep_ADD_SUBR(Swindow_get);
+    rep_ADD_SUBR(Smap_window_properties);
+    rep_ADD_SUBR(Swindow_put);
+    rep_ADD_SUBR(Swindow_name);
+    rep_ADD_SUBR(Swindow_full_name);
+    rep_ADD_SUBR(Swindow_icon_name);
+    rep_ADD_SUBR(Swindow_mapped_p);
+    rep_ADD_SUBR(Swindow_frame);
+    rep_ADD_SUBR(Sset_window_frame);
+    rep_ADD_SUBR(Srebuild_frame);
+    rep_ADD_SUBR(Swindow_position);
+    rep_ADD_SUBR(Swindow_dimensions);
+    rep_ADD_SUBR(Swindow_frame_dimensions);
+    rep_ADD_SUBR(Swindow_frame_offset);
+    rep_ADD_SUBR(Swindowp);
+    rep_ADD_SUBR(Sset_input_focus);
+    rep_ADD_SUBR(Sinput_focus);
+    rep_ADD_SUBR(Swindow_wants_input_p);
+    rep_ADD_SUBR(Smanaged_windows);
+    rep_ADD_SUBR(Sget_window_by_id);
+    rep_ADD_SUBR(Sstacking_order);
+    rep_ADD_SUBR(Swindow_visibility);
+    rep_ADD_SUBR(Swindow_transient_p);
+    rep_ADD_SUBR(Swindow_urgent_p);
+    rep_ADD_SUBR(Swindow_shaped_p);
+    rep_ADD_SUBR(Shide_window);
+    rep_ADD_SUBR(Sshow_window);
+    rep_ADD_SUBR(Swindow_visible_p);
+    rep_ADD_SUBR(Swindow_framed_p);
+    rep_ADD_SUBR(Swindow_id);
+    rep_ADD_SUBR(Swindow_group_id);
+    rep_ADD_SUBR(Swindow_size_hints);
+    rep_ADD_SUBR(Scall_window_hook);
+    rep_ADD_SUBR(Swindow_border_width);
+    rep_ADD_SUBR(Swindow_icon_image);
+    rep_ADD_SUBR(Smap_windows);
+    rep_ADD_SUBR(Sfilter_windows);
+    rep_pop_structure (tem);
+
+    rep_INTERN_SPECIAL(before_add_window_hook);
+    rep_INTERN_SPECIAL(add_window_hook);
+    rep_INTERN_SPECIAL(after_add_window_hook);
+    rep_INTERN_SPECIAL(place_window_hook);
+    rep_INTERN(placed);
+    rep_INTERN_SPECIAL(after_framing_hook);
+    rep_INTERN_SPECIAL(after_initialization_hook);
+    rep_INTERN_SPECIAL(remove_window_hook);
+
+    rep_INTERN(fully_obscured);
+    rep_INTERN(partially_obscured);
+    rep_INTERN(unobscured);
+
+    rep_INTERN(min_width);
+    rep_INTERN(min_height);
+    rep_INTERN(max_width);
+    rep_INTERN(max_height);
+    rep_INTERN(width_inc);
+    rep_INTERN(height_inc);
+    rep_INTERN(base_width);
+    rep_INTERN(base_height);
+    rep_INTERN(min_aspect);
+    rep_INTERN(max_aspect);
+    rep_INTERN(user_size);
+    rep_INTERN(user_position);
+    rep_INTERN(program_size);
+    rep_INTERN(program_position);
+    rep_INTERN(window_gravity);
+    rep_INTERN(forget);
+    rep_INTERN(static);
+    rep_INTERN(north_west);
+    rep_INTERN(north);
+    rep_INTERN(north_east);
+    rep_INTERN(west);
+    rep_INTERN(center);
+    rep_INTERN(east);
+    rep_INTERN(south_west);
+    rep_INTERN(south);
+    rep_INTERN(south_east);
+
+    gravity_map[ForgetGravity] = Qforget;
+    gravity_map[NorthWestGravity] = Qnorth_west;
+    gravity_map[NorthGravity] = Qnorth;
+    gravity_map[NorthEastGravity] = Qnorth_east;
+    gravity_map[WestGravity] = Qwest;
+    gravity_map[CenterGravity] = Qcenter;
+    gravity_map[EastGravity] = Qeast;
+    gravity_map[SouthWestGravity] = Qsouth_west;
+    gravity_map[SouthGravity] = Qsouth;
+    gravity_map[SouthEastGravity] = Qsouth_east;
+    gravity_map[StaticGravity] = Qstatic;
+}
+
+void
+windows_kill (void)
+{
+    Lisp_Window *w = window_list;
+    repv next;
+    rep_GC_root gc_next;
+    rep_PUSHGC (gc_next, next);
+    while (w != 0)
+    {
+	next = rep_VAL (w->next);
+	Fcall_window_hook (Qremove_window_hook, rep_VAL (w), Qnil, Qnil);
+	remove_window (w, Qnil, Qnil);
+	w = VWIN (next);
+    }
+}